Adobe ActionScript - 3.0 Manual de Programación [es]

Programación con

ADOBE

ACTIONSCRIPT® 3.0

Programación con Adobe

Si esta guía se distribuye con software que incluye un contrato de usuario final, la guía, así como el software descrito en ella, se proporciona con una licencia y sólo puede usarse o copiarse en conformidad con los términos de dicha licencia. Con la excepción de lo permitido por la licencia, ninguna parte de esta guía puede ser reproducida, almacenada en un sistema de recuperación de datos ni transmitida de ninguna forma ni por ningún medio, ya sea electrónico, mecánico, de grabación o de otro tipo, sin el consentimiento previo por escrito de Adobe Systems Incorporated. Tenga en cuenta que el contenido de esta guía está protegido por las leyes de derechos de autor aunque no se distribuya con software que incluya un contrato de licencia de usuario final.

El contenido de esta guía se proporciona exclusivamente con fines informativos, está sujeto a cambios sin previo aviso y no debe interpretarse como un compromiso de Adobe Systems Incorporated. Adobe Systems Incorporated no asume ninguna responsabilidad por los errores o imprecisiones que puedan existir en el contenido informativo de esta guía.

Recuerde que las ilustraciones o imágenes existentes que desee incluir en su proyecto pueden estar protegidas por las leyes de derechos de autor. La incorporación no autorizada de este material en sus trabajos puede infringir los derechos del propietario de los derechos de autor. Asegúrese de obtener los permisos necesarios del propietario de los derechos de autor.

Cualquier referencia a nombres de compañías en plantillas de ejemplo sólo se hace con propósitos de demostración y no está relacionada con ninguna organización real.

Adobe, the Adobe logo, Adobe AIR, ActionScript, Flash, Flash Lite, Flex, Flex Builder, MXML, and Pixel Bender are either registered trademarks or trademarks of Adobe Systems Incorporated in the United States and/or other countries.

ActiveX and Windows are either registered trademarks or trademarks of Microsoft Corporation in the United States and other countries. Macintosh is a trademark of Apple Inc., registered in the United States and other countries. Java is a trademark or registered trademark of Sun Microsystems, Inc. in the United States and other countries. All other trademarks are the property of their respective owners.

This product includes software developed by the Apache Software Foundation (

MPEG Layer-3 audio compression technology licensed by Fraunhofer IIS and Thomson Multimedia (

Speech compression and decompression technology licensed from Nellymoser, Inc. (

This product includes software developed by the OpenSymphony Group (

This product contains either BSAFE and/or TIPEM software by RSA Security, Inc.

® ActionScript® 3.0 para Adobe® Flash®

http://www.apache.org/).

http://www.mp3licensing.com)

www.nellymoser.com).

http://www.opensymphony.com/).

Sorenson Spark

Adobe Systems Incorporated, 345 Park Avenue, San Jose, California 95110, USA

Notice to U.S. government end users. The software and documentation are “Commercial Items,” as that term is defined at 48 C.F.R. §2.101, consisting of “Commercial Computer Software” and “Commercial Computer Software Documentation,” as such terms are used in 48 C.F.R. §12.212 or 48 C.F.R. §227.7202, as applicable. Consistent with 48 C.F.R. §12.212 or 48 C.F.R. §§227.7202-1 through 227.7202-4, as applicable, the Commercial Computer Software and Commercial Computer Software Documentation are being licensed to U.S. Government end users (a) only as Commercial items and (b) with only those rights as are granted to all other end users pursuant to the terms and conditions herein. Unpublished-rights reserved under the copyright laws of the United States. Adobe Systems Incorporated, 345 Park Avenue, San Jose, CA 95110-2704, USA. For U.S. Government End Users, Adobe agrees to comply with all applicable equal opportunity laws including, if appropriate, the provisions of Executive Order 11246, as amended, Section 402 of the Vietnam Era Veterans Readjustment Assistance Act of 1974 (38 USC 4212), and Section 503 of the Rehabilitation Act of 1973, as amended, and the regulations at 41 CFR Parts 60-1 through 60-60, 60-250 ,and 60-741. The affirmative action clause and regulations contained in the preceding sentence shall be incorporated by reference.

™ video compression and decompression technology licensed from Sorenson Media, Inc.

Contenido

Capítulo 1: Información sobre este manual

Utilización de este manual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

Acceso a la documentación de ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

Recursos de aprendizaje de ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

Capítulo 2: Introducción a ActionScript 3.0

ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

Ventajas de ActionScript 3.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

Novedades de ActionScript 3.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

Compatibilidad con versiones anteriores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

Capítulo 3: Introducción a ActionScript

Fundamentos de programación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

Trabajo con objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

Elementos comunes de los programas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

Ejemplo: Sitio de muestras de animación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

Creación de aplicaciones con ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

Creación de clases personalizadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

Ejemplo: Creación de una aplicación básica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

Ejecución de ejemplos posteriores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

iii

Capítulo 4: El lenguaje ActionScript y su sintaxis

Información general sobre el lenguaje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

Objetos y clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

Paquetes y espacios de nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

Tipos de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

Sintaxis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

Condicionales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

Reproducir indefinidamente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

Funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

Capítulo 5: Programación orientada a objetos con ActionScript

Fundamentos de la programación orientada a objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

Clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109

Herencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

Temas avanzados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119

Ejemplo: GeometricShapes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126

Capítulo 6: Trabajo con fechas y horas

Fundamentos de la utilización de fechas y horas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135

Administración de fechas de calendario y horas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Contenido

Control de intervalos de tiempo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

Ejemplo: Sencillo reloj analógico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140

Capítulo 7: Trabajo con cadenas

Fundamentos de la utilización de cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144

Creación de cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145

La propiedad length . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146

Trabajo con caracteres en cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146

Comparar cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147

Obtención de representaciones de cadena de otros objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148

Concatenación de cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148

Búsqueda de subcadenas y patrones en cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149

Conversión de cadenas de mayúsculas a minúsculas y viceversa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

Ejemplo: ASCII art . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

Capítulo 8: Trabajo con conjuntos

Fundamentos de la utilización de conjuntos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159

Conjuntos indexados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161

Conjuntos asociativos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172

Conjuntos multidimensionales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175

Clonación de conjuntos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177

Temas avanzados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177

Ejemplo: PlayList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182

Capítulo 9: Gestión de errores

Fundamentos de la gestión de errores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186

Tipos de errores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188

Gestión de errores en ActionScript 3.0 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190

Trabajo con las versiones de depuración de Flash Player y AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192

Gestión de errores sincrónicos en una aplicación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193

Creación de clases de error personalizadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

Respuesta al estado y a los eventos de error . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198

Comparación de las clases Error . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201

Ejemplo: Aplicación CustomErrors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206

Capítulo 10: Utilización de expresiones regulares

Fundamentos de la utilización de expresiones regulares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211

Sintaxis de las expresiones regulares . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213

Métodos para utilizar expresiones regulares con cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226

Ejemplo: Analizador Wiki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227

Capítulo 11: Trabajo con XML

Fundamentos de la utilización de XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232

El enfoque E4X del procesamiento de XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235

Objetos XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237

Objetos XMLList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239

Inicialización de variables XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240

Construcción y transformación de objetos XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Contenido

Navegación de estructuras XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243

Utilización de espacios de nombres XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247

Conversión de tipo XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248

Lectura de documentos XML externos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250

Ejemplo: Carga de datos de RSS desde Internet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250

Capítulo 12: Gestión de eventos

Fundamentos de la gestión de eventos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254

Diferencias entre la gestión de eventos en ActionScript 3.0 y en las versiones anteriores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257

El flujo del evento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259

Objetos de evento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260

Detectores de eventos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264

Ejemplo: Reloj con alarma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271

Capítulo 13: Programación de la visualización

Fundamentos de la programación de la visualización . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278

Clases principales de visualización . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282

Ventajas de la utilización de la lista de visualización . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283

Trabajo con objetos de visualización . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286

Manipulación de objetos de visualización . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 300

Animación de objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318

Carga dinámica de contenido de visualización . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320

Ejemplo: SpriteArranger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323

Capítulo 14: Utilización de la API de dibujo

Fundamentos de la utilización de la API de dibujo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329

Aspectos básicos de la clase Graphics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331

Dibujo de líneas y curvas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331

Dibujo de formas mediante los métodos incorporados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333

Creación de líneas y rellenos degradados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334

Utilización de la clase Math con los métodos de dibujo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338

Animación con la API de dibujo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339

Ejemplo: Generador visual algorítmico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340

Utilización avanzada de la API de dibujo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342

Trazados de dibujo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343

Definición de reglas de trazo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 345

Utilización de clases de datos gráficos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347

Utilización de drawTriangles() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350

Capítulo 15: Trabajo con la geometría

Fundamentos de geometría . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351

Utilización de objetos Point . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353

Utilización de objetos Rectangle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355

Utilización de objetos Matrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358

Ejemplo: Aplicación de una transformación de matriz a un objeto de visualización . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Contenido

Capítulo 16: Aplicación de filtros a objetos de visualización

Fundamentos de la aplicación de filtros a los objetos de visualización . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363

Creación y aplicación de filtros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364

Filtros de visualización disponibles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371

Ejemplo: Filter Workbench . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388

Capítulo 17: Trabajo con sombreados de Pixel Bender

Fundamentos de los sombreados de Pixel Bender . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395

Carga e incorporación de un sombreado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397

Acceso a los metadatos de sombreado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 399

Especificación de valores de entrada y parámetro de sombreado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400

Utilización de un sombreado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405

Capítulo 18: Trabajo con clips de película

Fundamentos de la utilización de película . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417

Trabajo con objetos MovieClip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419

Control de la reproducción de clips de película . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419

Creación de objetos MovieClip con ActionScript . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 422

Carga de un archivo SWF externo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424

Ejemplo: RuntimeAssetsExplorer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426

Capítulo 19: Trabajo con interpolaciones de movimiento

Fundamentos de interpolaciones de movimiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430

Copiar scripts de interpolación de movimiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431

Incorporación de scripts de interpolación de movimiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 432

Descripción de la animación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433

Añadir filtros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 435

Asociación de una interpolación de movimiento con sus objetos de visualización . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437

Capítulo 20: Trabajo con cinemática inversa

Fundamentos de cinemática inversa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438

Información general sobre animación de esqueletos IK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 439

Obtener información sobre un esqueleto IK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441

Creación de una instancia de la clase IKMover y limitación del movimiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441

Desplazamiento de un esqueleto IK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442

Utilización de eventos IK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442

Capítulo 21: Trabajo con texto

Fundamentos de la utilización de texto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444

Utilización de la clase TextField . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446

Utilización de Flash Text Engine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 468

Capítulo 22: Trabajo con mapas de bits

Fundamentos de la utilización de mapas de bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495

Las clases Bitmap y BitmapData . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 498

Manipulación de píxeles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 499

Copiar datos de mapas de bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502

Creación de texturas con funciones de ruido . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Contenido

Desplazarse por mapas de bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505

Aprovechamiento de la técnica de mipmapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506

Ejemplo: Luna giratoria animada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506

Capítulo 23: Trabajo en tres dimensiones (3D)

Fundamentos del concepto 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518

Aspectos básicos de las funciones 3D de Flash Player y el tiempo de ejecución de AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519

Creación y movimiento de objetos 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521

Proyección de objetos 3D en una vista bidimensional . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523

Ejemplo: Proyección en perspectiva . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 525

Transformaciones 3D complejas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 527

Utilización de triángulos para efectos 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 530

Capítulo 24: Trabajo con vídeo

Fundamentos de la utilización de vídeo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 538

Aspectos básicos de los formatos de vídeo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 540

Aspectos básicos de la clase Video . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543

Carga de archivos de vídeo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543

Control de la reproducción de vídeo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 544

Reproducción de vídeo en modo de pantalla completa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 546

Transmisión de archivos de vídeo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550

Aspectos básicos de los puntos de referencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 550

Escritura de métodos callback para metadatos y puntos de referencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 551

Utilización de puntos de referencia y metadatos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 556

Captura de entradas de cámara . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565

Envío de vídeo a un servidor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 571

Temas avanzados para archivos FLV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 572

Ejemplo: Gramola de vídeo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 573

vii

Capítulo 25: Trabajo con sonido

Fundamentos de la utilización de sonido . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 579

Aspectos básicos de la arquitectura de sonido . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 581

Carga de archivos de sonido externos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 582

Trabajo con sonidos incorporados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 584

Trabajo con archivos de flujo de sonido . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 585

Trabajo con sonido generado dinámicamente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 586

Reproducción de sonidos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 588

Consideraciones de seguridad al cargar y reproducir sonidos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 592

Control de desplazamiento y volumen de sonido . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593

Trabajo con metadatos de sonido . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594

Acceso a datos de sonido sin formato . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 595

Captura de entradas de sonido . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 599

Ejemplo: Podcast Player . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 602

Capítulo 26: Captura de entradas del usuario

Fundamentos de la captura de entradas del usuario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 610

Captura de entradas de teclado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 611

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Contenido

Captura de entradas de ratón . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 613

Ejemplo: WordSearch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 617

Capítulo 27: Redes y comunicación

Fundamentos de redes y comunicación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621

Trabajo con datos externos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624

Conexión con otras instancias de Flash Player y AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 629

Conexiones de socket . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 634

Almacenamiento de datos locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 638

Trabajo con archivos de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 640

Ejemplo: Generación de un cliente Telnet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 654

Ejemplo: Carga y descarga de archivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 657

Capítulo 28: Entorno del sistema del cliente

Fundamentos del entorno del sistema del cliente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 663

Utilización de la clase System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 665

Utilización de la clase Capabilities . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 666

Utilización de la clase ApplicationDomain . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 667

Utilización de la clase IME . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669

Ejemplo: Detección de las características del sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 674

viii

Capítulo 29: Copiar y pegar

Conceptos básicos de copiar y pegar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 678

Lectura y escritura en el portapapeles del sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 678

Formatos de datos del portapapeles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 679

Capítulo 30: Impresión

Fundamentos de impresión . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 684

Impresión de una página . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 685

Interfaz de impresión del sistema y tareas de Flash Player y AIR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 686

Configuración del tamaño, la escala y la orientación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 689

Ejemplo: Impresión de varias páginas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 690

Ejemplo: Ajuste de escala, recorte y respuesta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 692

Capítulo 31: Utilización de la API externa

Fundamentos de la utilización de la API externa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 695

Requisitos y ventajas de la API externa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 697

Utilización de la clase ExternalInterface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 698

Ejemplo: Utilización de la API externa con una página Web contenedora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 702

Ejemplo: Utilización de la API externa con un contenedor ActiveX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 708

Capítulo 32: Seguridad de Flash Player

Información general sobre la seguridad de Flash Player . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 714

Entornos limitados de seguridad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 716

Controles de permiso . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 718

Restricción de las API de red . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 725

Seguridad del modo de pantalla completa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 727

Carga de contenido . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 729

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Contenido

Reutilización de scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 731

Acceso a medios cargados como datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 734

Carga de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 737

Carga de contenido incorporado de archivos SWF importados en un dominio de seguridad . . . . . . . . . . . . . . . . . . . . . . . . . . . 739

Trabajo con contenido heredado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 740

Configuración de permisos de LocalConnection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 740

Control del acceso URL saliente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 741

Objetos compartidos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 742

Acceso a la cámara, el micrófono, el portapapeles, el ratón y el teclado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 744

Índice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 745

Capítulo 1: Información sobre este manual

En este manual se ofrecen unas bases para el desarrollo de aplicaciones en Adobe® ActionScript® 3.0. Para comprender mejor las ideas y las técnicas descritas, debe estar familiarizado con conceptos de programación generales como, por ejemplo, tipos de datos, variables, bucles y funciones. También hay que conocer conceptos básicos sobre la programación orientada a objetos, como los conceptos de clase y herencia. Un conocimiento previo de ActionScript

1.0 o ActionScript 2.0 es útil pero no necesario.

Utilización de este manual

Los capítulos de este manual están organizados en los siguientes grupos lógicos para ayudarle a encontrar áreas relacionadas de la documentación de ActionScript:

Capítulo Descripción

En los capítulos 2 a 5 se ofrece información general sobre la programación en ActionScript.

En los capítulos 6 a 11, se describen las clases y los tipos de datos básicos de ActionScript 3.0.

En los capítulos 12 a 32, se describen las API de Flash Player y de Adobe AIR.

Se abordan los conceptos básicos de ActionScript 3.0, incluida la sintaxis del lenguaje, sentencias, operadores y programación ActionScript orientada a objetos.

Se describen los tipos de datos de nivel superior de ActionScript 3.0.

Se describen funciones importantes implementadas en paquetes y clases específicos de Adobe Flash Player y Adobe AIR, como el control de eventos, los objetos y la lista de visualización, las conexiones de red y las comunicaciones, la entrada y salida de archivos, la interfaz externa, el modelo de seguridad de aplicaciones, etc.

Este manual también contiene numerosos archivos de ejemplo que ilustran conceptos de programación de aplicaciones para clases importantes o utilizadas frecuentemente. Los archivos de ejemplo se empaquetan de forma que resulten fáciles de cargar y utilizar con Adobe® Flash® CS4 Professional y pueden incluir archivos envolventes. Sin embargo, el núcleo del código de ejemplo es puro código ActionScript 3.0 que se puede utilizar en el entorno de desarrollo que se prefiera.

Se puede escribir y compilar código ActionScript 3.0 de varias maneras:

• Mediante el entorno de desarrollo Adobe Flex Builder 3.

• Utilizando cualquier editor de texto y un compilador de línea de comandos, como el proporcionado con Flex

Builder 3.

• Usando la herramienta de edición Adobe ® Flash® CS4 Professional.

Para obtener más información sobre los entornos de desarrollo de ActionScript, consulte “Introducción a ActionScript

3.0” en la página 4

Para comprender los ejemplos de código de este manual no es necesario tener experiencia previa en el uso de entornos de desarrollo integrados para ActionScript, como Flex Builder o la herramienta de edición de Flash. No obstante, es conveniente consultar la documentación de estas herramientas para aprender a utilizarlas y a escribir y compilar código ActionScript 3.0. Para obtener más información, consulte “Acceso a la documentación de ActionScript” en la página 2.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Información sobre este manual

Acceso a la documentación de ActionScript

Este manual se centra en describir ActionScript 3.0, un completo y eficaz lenguaje de programación orientado a objetos. No incluye una descripción detallada del proceso de desarrollo de aplicaciones ni del flujo de trabajo en una herramienta o arquitectura de servidor específica. Por ello, además de leer Programación con ActionScript 3.0, es recomendable consultar otras fuentes de documentación al diseñar, desarrollar, probar e implementar aplicaciones de ActionScript 3.0.

Documentación de ActionScript 3.0

En este manual se explican los conceptos relacionados con la programación en ActionScript 3.0, se muestran los detalles de implementación y se proporcionan ejemplos que ilustran las características importantes del lenguaje. No obstante, este manual no es una referencia del lenguaje exhaustiva. Para una referencia completa, consulte la Referencia del lenguaje y componentes ActionScript 3.0, en la que se describen todas las clases, métodos, propiedades y eventos del lenguaje. La Referencia del lenguaje y componentes ActionScript 3.0 proporciona información de referencia detallada sobre el núcleo del lenguaje, los componentes de la herramienta de edición de Flash (paquetes fl) y las API de Flash Player y de Adobe AIR (paquetes flash).

Documentación de Flash

Si utiliza la herramienta de edición de Flash, es posible que desee consultar estos manuales:

Manual Descripción

Utilización de Flash Describe la manera de desarrollar aplicaciones Web dinámicas en la herramienta

Programación con ActionScript 3.0 Describe el uso específico del lenguaje ActionScript 3.0 y la API principal de Flash

Referencia del lenguaje y componentes ActionScript 3.0 Proporciona información sobre la sintaxis y el uso, así como ejemplos de código,

Utilización de componentes ActionScript 3.0 Explica los detalles del uso de componentes para desarrollar aplicaciones creadas

Desarrollo de aplicaciones de Adobe AIR con Flash CS4 Professional

Aprendizaje de ActionScript 2.0 en Adobe Flash Proporciona información general sobre la sintaxis de ActionScript 2.0 y sobre

Referencia del lenguaje ActionScript 2.0 Proporciona información sobre la sintaxis y el uso, así como ejemplos de código,

Utilización de componentes ActionScript 2.0 Explica de forma detallada cómo utilizar componentes de ActionScript 2.0 para

Referencia del lenguaje de componentes ActionScript 2.0 Describe cada componente disponible en la versión 2 de la arquitectura de

Ampliación de Flash Describe los objetos, métodos y propiedades disponibles en la API de JavaScript

de edición de Flash.

Player y de Adobe AIR

para los componentes de la herramienta de edición de Flash y la API de ActionScript 3.0.

por Flash.

Describe cómo desarrollar e implementar aplicaciones de Adobe AIR utilizando ActionScript 3.0 y la API de Adobe AIR en Flash

cómo utilizar ActionScript 2.0 al trabajar con distintos tipos de objetos

para los componentes de la herramienta de edición de Flash y la API de ActionScript 2.0.

desarrollar aplicaciones creadas por Flash.

componentes de Adobe, junto con su API

Introducción a Flash Lite 2.x

Explica cómo utilizar Adobe proporciona información sobre la sintaxis y el uso, así como ejemplos de código para las funciones de ActionScript disponibles en Flash Lite 2.x

® Flash® Lite™ 2.x para desarrollar aplicaciones y

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Información sobre este manual

Manual Descripción

Desarrollo de aplicaciones de Flash Lite 2.x Explica cómo desarrollar aplicaciones de Flash Lite 2.x

Introducción a ActionScript en Flash Lite 2.x Ofrece una introducción al desarrollo de aplicaciones Flash Lite 2.x y describe

Referencia del lenguaje ActionScript de Flash Lite 2.x Proporciona información sobre la sintaxis y el uso, así como ejemplos de código,

Introducción a Flash Lite 1.x Proporciona una introducción a Flash Lite 1.x y describe el modo de comprobar

Desarrollo de aplicaciones de Flash Lite 1.x Describe la manera de desarrollar aplicaciones para dispositivos móviles con Flash

Aprendizaje de ActionScript en Flash Lite 1.x Explica cómo utilizar ActionScript en aplicaciones de Flash Lite 1.x y describe

Referencia del lenguaje ActionScript de Flash Lite 1.x Describe la sintaxis y el modo de uso de los elementos de ActionScript disponibles

todas las funciones de ActionScript disponibles para los desarrolladores de Flash Lite 2.x

de la API de ActionScript 2.0 disponible en Flash Lite 2.x

contenido con el emulador de Adobe® Device Central CS4

Lite 1.x

todas las funciones de ActionScript disponibles en Flash Lite 1.x

en Flash Lite 1.x

Recursos de aprendizaje de ActionScript

Además del contenido de estos manuales, Adobe proporciona regularmente artículos actualizados, ideas de diseño y ejemplos en el Centro de desarrollo de Adobe y el Centro de diseño de Adobe.

Centro de desarrollo de Adobe

El Centro de desarrollo de Adobe contiene la información más actualizada sobre ActionScript, artículos sobre el desarrollo de aplicaciones reales e información sobre nuevos problemas importantes. Consulte el Centro de desarrollo de Adobe en http://www.adobe.com/es/devnet/.

Centro de diseño de Adobe

Póngase al día en diseño digital y gráficos en movimiento. Examine la obra de importantes artistas, descubra las nuevas tendencias de diseño y mejore sus conocimientos con tutoriales, flujos de trabajo clave y técnicas avanzadas. Consulte el centro cada quince días para ver tutoriales y artículos nuevos e inspirarse con las creaciones de las galerías. Consulte el centro de diseño en www.adobe.com/designcenter/.

Capítulo 2: Introducción a ActionScript

3.0

En este capítulo se ofrece información general sobre Adobe® ActionScript® 3.0, una de las versiones más recientes e innovadoras de ActionScript.

ActionScript

ActionScript es el lenguaje de programación para los entornos de tiempo de ejecución de Adobe® Flash® Player y Adobe® AIR™. Entre otras muchas cosas, activa la interactividad y la gestión de datos en el contenido y las aplicaciones de Flash, Flex y AIR.

ActionScript se ejecuta mediante la máquina virtual ActionScript (AVM), que forma parte de Flash Player y AIR. El código de ActionScript se suele compilar en un formato de código de bytes (un tipo de lenguaje que los ordenadores pueden escribir y comprender) mediante un compilador, como el incorporado en Adobe® Flash® CS4 Professional o Adobe® Flex™ Builder™ o el que está disponible en el SDK de Adobe® Flex™. El código de bytes está incorporado en los archivos SWF ejecutados por Flash Player y AIR.

ActionScript 3.0 ofrece un modelo de programación robusto que resultará familiar a los desarrolladores con conocimientos básicos sobre programación orientada a objetos. Algunas de las principales funciones de ActionScript

3.0 que mejoran las versiones anteriores son:

• Una nueva máquina virtual de ActionScript, denominada AVM2, que utiliza un nuevo conjunto de instrucciones

de código de bytes y proporciona importantes mejoras de rendimiento.

• Una base de código de compilador más moderna que realiza mejores optimizaciones que las versiones anteriores

del compilador.

• Una interfaz de programación de aplicaciones (API) ampliada y mejorada, con un control de bajo nivel de los

objetos y un auténtico modelo orientado a objetos.

• Una API XML basada en la especificación de ECMAScript para XML (E4X) (ECMA-357 edición 2). E4X es una

extensión del lenguaje ECMAScript que añade XML como un tipo de datos nativo del lenguaje.

• Un modelo de eventos basado en la especificación de eventos DOM (modelo de objetos de documento) de nivel 3.

Ventajas de ActionScript 3.0

ActionScript 3.0 aumenta las posibilidades de creación de scripts de las versiones anteriores de ActionScript. Se ha diseñado para facilitar la creación de aplicaciones muy complejas con conjuntos de datos voluminosos y bases de código reutilizables y orientadas a objetos. Aunque no se requiere para el contenido que se ejecuta en Adobe Flash Player, ActionScript 3.0 permite introducir unas mejoras de rendimiento que sólo están disponibles con AVM2, la nueva máquina virtual. El código ActionScript 3.0 puede ejecutarse con una velocidad diez veces mayor que el código ActionScript heredado.

La versión anterior de la máquina virtual ActionScript (AVM1) ejecuta código ActionScript 1.0 y ActionScript 2.0. Flash Player 9 y 10 admiten AVM9 por compatibilidad con contenido existente y heredado de versiones anteriores. Para obtener más información, consulte “Compatibilidad con versiones anteriores” en la página 7.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript 3.0

Novedades de ActionScript 3.0

Aunque ActionScript 3.0 contiene muchas clases y funciones que resultarán familiares a los programadores de ActionScript, la arquitectura y los conceptos de ActionScript 3.0 difieren de las versiones anteriores de ActionScript. ActionScript 3.0 incluye algunas mejoras como, por ejemplo, nuevas funciones del núcleo del lenguaje y una API de Flash Player mejorada que proporciona un mayor control de objetos de bajo nivel.

Nota: las aplicaciones de Adobe® AIR™ también pueden utilizar las API de Flash Player.

Funciones del núcleo del lenguaje

El núcleo del lenguaje está formado por los bloques básicos del lenguaje de programación, como sentencias, expresiones, condiciones, bucles y tipos. ActionScript 3.0 contiene muchas funciones nuevas que aceleran el proceso de desarrollo.

Excepciones de tiempo de ejecución

ActionScript 3.0 notifica más situaciones de error que las versiones anteriores de ActionScript. Las excepciones de tiempo de ejecución se utilizan en situaciones de error frecuentes y permiten mejorar la depuración y desarrollar aplicaciones para gestionar errores de forma robusta. Los errores de tiempo de ejecución pueden proporcionar trazas de pila con la información del archivo de código fuente y el número de línea. Esto permite identificar rápidamente los errores.

Tipos de tiempo de ejecución

En ActionScript 2.0, las anotaciones de tipos eran principalmente una ayuda para el desarrollador; en tiempo de ejecución, se asignaban los tipos dinámicamente a todos los valores. En ActionScript 3.0, la información de tipos se conserva en tiempo de ejecución y se utiliza con diversos fines. Flash Player y Adobe AIR realizan una verificación de tipos en tiempo de ejecución, mejorando la seguridad de los tipos del sistema. La información de tipos también se utiliza para especificar variables en representaciones nativas de la máquina, lo que mejora el rendimiento y reduce el uso de memoria.

Clases cerradas

ActionScript 3.0 introduce el concepto de clases cerradas. Una clase cerrada posee únicamente el conjunto fijo de propiedades y métodos definidos durante la compilación; no es posible añadir propiedades y métodos adicionales. Esto permite realizar una comprobación más estricta en tiempo de compilación, lo que aporta una mayor solidez a los programas. También mejora el uso de memoria, pues no requiere una tabla hash interna para cada instancia de objeto. Además, es posible utilizar clases dinámicas mediante la palabra clave están cerradas de forma predeterminada, pero pueden declararse como dinámicas con la palabra clave

Cierres de métodos

ActionScript 3.0 permite que un cierre de método recuerde automáticamente su instancia de objeto original. Esta función resulta útil en la gestión de eventos. En ActionScript 2.0, los cierres de métodos no recordaban la instancia de objeto de la que se habían extraído, lo que provocaba comportamientos inesperados cuando se llamaba al cierre de método. La clase mx.utils.Delegate permitía solucionar este problema, pero ya no es necesaria.

dynamic. Todas las clases de ActionScript 3.0

dynamic.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript 3.0

ECMAScript for XML (E4X)

ActionScript 3.0 implementa ECMAScript for XML (E4X), recientemente estandarizado como ECMA-357. E4X ofrece un conjunto fluido y natural de construcciones del lenguaje para manipular XML. Al contrario que las API de análisis de XML tradicionales, XML con E4X se comporta como un tipo de datos nativo del lenguaje. E4X optimiza el desarrollo de aplicaciones que manipulan XML, pues reduce drásticamente la cantidad de código necesario. Para obtener más información sobre la implementación de E4X en ActionScript 3.0, consulte “Trabajo con XML” en la página 232.

Para ver la especificación de E4X publicada por ECMA, visite www.ecma-international.org.

Expresiones regulares

ActionScript 3.0 ofrece compatibilidad nativa con expresiones regulares, que permiten encontrar y manipular cadenas rápidamente. ActionScript 3.0 implementa la compatibilidad con expresiones regulares tal y como se definen en la especificación del lenguaje ECMAScript (ECMA-262) edición 3.

Espacios de nombres

Los espacios de nombres son similares a los especificadores de acceso tradicionales que se utilizan para controlar la visibilidad de las declaraciones (

public, private, protected). Funcionan como especificadores de acceso

personalizados, con nombres elegidos por el usuario. Los espacios de nombres incluyen un identificador de recursos universal (URI) para evitar colisiones y también se utilizan para representar espacios de nombres XML cuando se trabaja con E4X.

Nuevos tipos simples

ActionScript 2.0 tiene un solo tipo numérico, Number, un número de coma flotante con precisión doble. ActionScript

3.0 contiene los tipos int y uint. El tipo int es un entero de 32 bits con signo que permite al código ActionScript aprovechar las capacidades matemáticas de manipulación rápida de enteros de la CPU. Este tipo es útil para contadores de bucle y variables en las que se usan enteros. El tipo uint es un tipo entero de 32 bits sin signo que resulta útil para valores de colores RGB y recuentos de bytes, entre otras cosas.

Funciones de la API de Flash Player

Las API de Flash Player en ActionScript 3.0 contienen muchas de las clases que permiten controlar objetos a bajo nivel. La arquitectura del lenguaje está diseñada para ser mucho más intuitiva que en versiones anteriores. Hay demasiadas clases nuevas para poder tratarlas con detalle, de modo que en las siguientes secciones se destacan algunos cambios importantes.

Nota: las aplicaciones de Adobe® AIR™ también puede utilizar las API de Flash Player.

Modelo de eventos DOM3

El modelo de eventos del modelo de objetos de documento de nivel 3 (DOM3) ofrece un modo estándar para generar y gestionar mensajes de eventos de forma que los objetos de las aplicaciones puedan interactuar y comunicarse, mantener su estado y responder a los cambios. Diseñado a partir de la especificación de eventos DOM de nivel 3 del World Wide Web Consortium, este modelo proporciona un mecanismo más claro y eficaz que los sistemas de eventos disponibles en versiones anteriores de ActionScript.

Los eventos y los eventos de error se encuentran en el paquete flash.events. La arquitectura de componentes de Flash utiliza el mismo modelo de eventos que la API de Flash Player, de forma que el sistema de eventos está unificado en toda la plataforma Flash.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript 3.0

API de la lista de visualización

La API de acceso a la lista de visualización de Flash Player y Adobe AIR (el árbol que contiene todos los elementos visuales de una aplicación Flash) se compone de clases para trabajar con elementos visuales simples.

La nueva clase Sprite es un bloque básico ligero, similar a la clase MovieClip pero más apropiado como clase base de los componentes de interfaz de usuario. La nueva clase Shape representa formas vectoriales sin procesar. Es posible crear instancias de estas clases de forma natural con el operador

new y se puede cambiar el elemento principal en

cualquier momento, de forma dinámica.

La administración de profundidad es ahora automática y está incorporada en Flash Player y Adobe AIR, por lo que ya no es necesario asignar valores de profundidad. Se proporcionan nuevos métodos para especificar y administrar el orden z de los objetos.

Gestión de contenido y datos dinámicos

ActionScript 3.0 contiene mecanismos para cargar y gestionar elementos y datos en la aplicación, que son intuitivos y coherentes en toda la API. La nueva clase Loader ofrece un solo mecanismo para cargar archivos SWF y elementos de imagen, y proporciona una forma de acceso a información detallada sobre el contenido cargado. La clase URLLoader proporciona un mecanismo independiente para cargar texto y datos binarios en aplicaciones basadas en datos. La clase Socket proporciona una forma de leer y escribir datos binarios en sockets de servidor en cualquier formato.

Acceso a datos de bajo nivel

Diversas API proporcionan acceso de bajo nivel a los datos, lo que supone una novedad en ActionScript. La clase URLStream, implementada por URLLoader, proporciona acceso a los datos como datos binarios sin formato mientras se descargan. La clase ByteArray permite optimizar la lectura, escritura y utilización de datos binarios. La nueva API Sound proporciona control detallado del sonido a través de las clases SoundChannel y SoundMixer. Las nuevas API relacionadas con la seguridad proporcionan información sobre los privilegios de seguridad de un archivo SWF o contenido cargado, lo que permite gestionar mejor los errores de seguridad.

Trabajo con texto

ActionScript 3.0 contiene un paquete flash.text para todas las API relacionadas con texto. La clase TextLineMetrics proporciona medidas detalladas para una línea de texto en un campo de texto; sustituye al método

TextFormat.getTextExtent() en ActionScript 2.0. La clase TextField contiene una serie de nuevos métodos

interesantes de bajo nivel que pueden ofrecer información específica sobre una línea de texto o un solo carácter en un campo de texto. Dichos métodos son: de delimitación de un carácter, especificado, y de nivel de línea son:

getLineText(), que devuelve el texto de la línea especificada. Una nueva clase Font proporciona un medio para

getFirstCharInParagraph(), que devuelve el índice del primer carácter en un párrafo. Los métodos

getLineLength(), que devuelve el número de caracteres en una línea de texto especificada, y

getCharBoundaries(), que devuelve un rectángulo que representa el recuadro

getCharIndexAtPoint(), que devuelve el índice del carácter en un punto

administrar las fuentes incorporadas en archivos SWF.

Compatibilidad con versiones anteriores

Como siempre, Flash Player proporciona compatibilidad completa con el contenido publicado previamente con versiones anteriores. Cualquier contenido que se ejecutara en versiones anteriores de Flash Player puede ejecutarse en Flash Player 9. Sin embargo, la introducción de ActionScript 3.0 en Flash Player 9 presenta algunos retos de interoperabilidad entre el contenido antiguo y el contenido nuevo que se ejecuta en Flash Player 9. Algunos de los problemas de compatibilidad que pueden surgir son:

• No se puede combinar código ActionScript 1.0 ó 2.0 con código ActionScript 3.0 en un archivo SWF.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript 3.0

• El código ActionScript 3.0 puede cargar un archivo SWF escrito en ActionScript 1.0 ó 2.0, pero no puede acceder a

las variables y funciones del archivo SWF.

• Los archivos SWF escritos en ActionScript 1.0 ó 2.0 no pueden cargar archivos SWF escritos en ActionScript 3.0.

Esto significa que los archivos SWF creados en Flash 8 o Flex Builder 1.5 o versiones anteriores no pueden cargar archivos SWF de ActionScript 3.0.

La única excepción a esta regla es que un archivo SWF de ActionScript 2.0 puede sustituirse a sí mismo por un archivo SWF de ActionScript 3.0, siempre y cuando el archivo SWF de ActionScript 2.0 no haya cargado ningún elemento en ninguno de sus niveles. Para ello, el archivo SWF de ActionScript 2.0 debe realizar una llamada a

loadMovieNum(), pasando un valor 0 al parámetro level.

• En general, los archivos SWF escritos en ActionScript 1.0 ó 2.0 se deben migrar si van a funcionar de forma

conjunta con los archivos SWF escritos en ActionScript 3.0. Por ejemplo, supongamos que se ha creado un reproductor de medios utilizando ActionScript 2.0. El reproductor carga distinto contenido que también se creó utilizando ActionScript 2.0. No es posible crear nuevo contenido en ActionScript 3.0 y cargarlo en el reproductor de medios. Es necesario migrar el reproductor de vídeo a ActionScript 3.0.

No obstante, si se crea un reproductor de medios en ActionScript 3.0, dicho reproductor puede realizar cargas sencillas del contenido de ActionScript 2.0.

En la siguiente tabla se resumen las limitaciones de las versiones anteriores de Flash Player en lo referente a la carga de nuevo contenido y a la ejecución de código, así como las limitaciones relativas a la reutilización de scripts entre archivos SWF escritos en distintas versiones de ActionScript.

Funcionalidad admitida Flash Player 7 Flash Player 8 Flash Player 9 y 10

Puede cargar archivos SWF publicados para 7 y versiones anteriores 8 y versiones anteriores 9 (o 10) y versiones anteriores

Contiene esta AVM AVM1 AVM1 AVM1 y AVM2

Ejecuta archivos SWF escritos en ActionScript

1.0 y 2.0 1.0 y 2.0 1.0, 2.0 y 3.0

En la siguiente tabla, “Funcionalidad admitida” hace referencia al contenido que se ejecuta en Flash Player 9 o posterior. El contenido ejecutado en Flash Player 8 o versiones anteriores puede cargar, mostrar, ejecutar y reutilizar scripts únicamente de ActionScript 1.0 y 2.0.

Funcionalidad admitida Contenido creado en ActionScript 1.0 y 2.0 Contenido creado en ActionScript 3.0

Puede cargar contenido y ejecutar código en contenido creado en

Puede reutilizar contenido de scripts creado en

Sólo ActionScript 1.0 y 2.0 ActionScript 1.0 y 2.0, y ActionScript 3.0

Sólo ActionScript 1.0 y 2.0 (ActionScript 3.0 a través de conexión local)

ActionScript 1.0 y 2.0 a través de LocalConnection.

ActionScript 3.0

Capítulo 3: Introducción a ActionScript

Este capítulo se ha diseñado como punto de partida para empezar a programar en ActionScript. Aquí se proporcionan las bases necesarias para comprender los conceptos y ejemplos descritos en el resto de páginas de este manual. Para comenzar, se ofrece una descripción de los conceptos básicos de programación en el contexto de su aplicación en ActionScript. También se tratan los aspectos fundamentales de la organización y creación de una aplicación ActionScript.

Fundamentos de programación

Dado que ActionScript es un lenguaje de programación, será de gran ayuda comprender primero algunos conceptos generales de programación de ordenadores.

Para qué sirven los programas informáticos

En primer lugar, resulta útil entender qué es un programa informático y para qué sirve. Un programa informático se caracteriza por dos aspectos principales:

• Un programa es una serie de instrucciones o pasos que debe llevar a cabo el equipo.

• Cada paso implica en última instancia la manipulación de información o datos.

En general, un programa informático es simplemente una lista de instrucciones paso a paso que se dan al equipo para que las lleve a cabo una a una. Cada una de las instrucciones se denomina sentencia. Como se verá a lo largo de este manual, en ActionScript cada sentencia finaliza con un punto y coma.

Lo que realiza básicamente una instrucción dada en un programa es manipular algún bit de datos almacenado en la memoria del equipo. En un caso sencillo, se puede indicar al equipo que sume dos números y almacene el resultado en su memoria. En un caso más complejo, se podría tener un rectángulo dibujado en la pantalla y escribir un programa para moverlo a algún otro lugar de la pantalla. El equipo realiza un seguimiento de determinada información relativa al rectángulo: las coordenadas x e y que indican su ubicación, la anchura y altura, el color, etc. Cada uno de estos bits de información se almacena en algún lugar de la memoria del equipo. Un programa para mover el rectángulo a otra ubicación incluiría pasos como "cambiar la coordenada x a 200; cambiar la coordenada y a 150" (especificando nuevos valores para las coordenadas x e y). Por supuesto, el equipo procesa estos datos de algún modo para convertir estos números en la imagen que aparece en la pantalla; pero para el nivel de detalle que aquí interesa, basta con saber que el proceso de "mover un rectángulo en la pantalla" sólo implica en realidad un cambio de bits de datos en la memoria del equipo.

Variables y constantes

Dado que la programación implica principalmente cambiar datos en la memoria del equipo, tiene que haber una forma de representar un solo dato en el programa. Una variable es un nombre que representa un valor en la memoria del equipo. Cuando se escriben sentencias para manipular valores, se escribe el nombre de la variable en lugar del valor; cuando el equipo ve el nombre de la variable en el programa, busca en su memoria y utiliza el valor que allí encuentra. Por ejemplo, si hay dos variables denominadas sumar esos dos números se podría escribir la sentencia:

value1 y value2, cada una de las cuales contiene un número, para

value1 + value2

Cuando lleve a cabo los pasos indicados, el equipo buscará los valores de cada variable y los sumará.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

En ActionScript 3.0, una variable se compone realmente de tres partes distintas:

• El nombre de la variable

• El tipo de datos que puede almacenarse en la variable

• El valor real almacenado en la memoria del equipo

Se acaba de explicar cómo el equipo utiliza el nombre como marcador de posición del valor. El tipo de datos también es importante. Cuando se crea una variable en ActionScript, se especifica el tipo concreto de datos que contendrá; a partir de ahí, las instrucciones del programa sólo pueden almacenar ese tipo de datos en la variable y se puede manipular el valor con las características particulares asociadas a su tipo de datos. En ActionScript, para crear una variable (se conoce como declarar la variable), se utiliza la sentencia

var value1:Number;

var:

En este caso, se ha indicado al equipo que cree una variable denominada value1, que contendrá únicamente datos numéricos ("Number" es un tipo de datos específico definido en ActionScript). También es posible almacenar un valor directamente en la variable:

var value2:Number = 17;

En Adobe Flash CS4 Professional hay otra forma posible de declarar una variable. Cuando se coloca un símbolo de clip de película, un símbolo de botón o un campo de texto en el escenario, se le puede asignar un nombre de instancia en el inspector de propiedades. En segundo plano, Flash crea una variable con el mismo nombre que la instancia, que se puede utilizar en el código ActionScript para hacer referencia a ese elemento del escenario. Así, por ejemplo, si hay un símbolo de clip de película en el escenario y se le asigna el nombre de instancia variable

rocketShip en el código ActionScript, se estará manipulando dicho clip de película.

rocketShip, siempre que se use la

Una constante es muy similar a una variable en el sentido de que es un nombre que representa a un valor en la memoria del equipo, con un tipo de datos específico. La diferencia es que a una constante sólo se le puede asignar un valor cada vez en el curso de una aplicación ActionScript. Tras asignar un valor a una constante, éste permanecerá invariable en toda la aplicación. La sintaxis para declarar constantes coincide con la de las variables, excepto por el hecho de que se usa la palabra clave

const SALES_TAX_RATE:Number = 0.07;

const en lugar de var:

Una constante resulta útil para definir un valor que se utilizará en varios puntos de un proyecto y que no cambiará en circunstancias normales. Cuando se utiliza una constante en lugar de un valor literal el código resulta más legible. Por ejemplo, es más fácil entender la finalidad de una línea de código que multiplica un precio por la de una línea de código que lo haga por

0.07. Además, si en un momento dado es preciso cambiar el valor definido

SALES_TAX_RATE que

por una constante, sólo habrá que hacerlo en un punto (la declaración de la constante) cuando se utiliza una constante para su representación en el proyecto, en lugar de tener que modificarlo varias veces como cuando se utilizan valores literales especificados en el código.

Tipos de datos

En ActionScript, hay muchos tipos de datos que pueden utilizarse como el tipo de datos de las variables que se crean. Algunos de estos tipos de datos se pueden considerar "sencillos" o "fundamentales":

• String: un valor de texto como, por ejemplo, un nombre o el texto de un capítulo de un libro

• Numeric: ActionScript 3.0 incluye tres tipos de datos específicos para datos numéricos:

• Number: cualquier valor numérico, incluidos los valores fraccionarios o no fraccionarios

• int: un entero (un número no fraccionario)

• uint: un entero sin signo, es decir, que no puede ser negativo

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

• Boolean: un valor true (verdadero) o false (falso), por ejemplo, si un conmutador está activado o si dos valores son

iguales

El tipo de datos sencillo representa a un solo elemento de información: por ejemplo, un único número o una sola secuencia de texto. No obstante, la mayoría de los tipos de datos definidos en ActionScript podrían describirse como tipos de datos complejos porque representan un conjunto de valores agrupados. Por ejemplo, una variable con el tipo de datos Date representa un solo valor: un momento temporal. No obstante, ese valor de fecha se representa en realidad en forma de diferentes valores: el día, el mes, el año, las horas, los minutos, los segundos, etc., los cuales son números individuales. Así pues, aunque se perciba una fecha como un solo valor (y se pueda tratar como tal creando una variable Date), internamente el equipo lo considera un grupo de varios valores que conjuntamente definen una sola fecha.

La mayoría de los tipos de datos incorporados y los tipos de datos definidos por los programadores son complejos. Algunos de los tipos de datos complejos que podrían reconocerse son:

• MovieClip: un símbolo de clip de película

• TextField: un campo de texto dinámico o de texto de entrada

• SimpleButton: un símbolo de botón

• Date: información sobre un solo momento temporal (una fecha y hora)

Para referirse a los tipos de datos, a menudo se emplean como sinónimos las palabras clase y objeto. Una clase es simplemente la definición de un tipo de datos — es una especie de plantilla para todos los objetos del tipo de datos, como afirmar que "todas las variables del tipo de datos Example tiene estas características: A, B y C". Un objeto, por otra parte, es una instancia real de una clase; una variable cuyo tipo de datos sea MovieClip se podría describir como un objeto MovieClip. Se puede decir lo mismo con distintos enunciados:

• El tipo de datos de la variable myVariable es Number.

• La variable myVariable es una instancia de Number.

• La variable myVariable es un objeto Number.

• La variable myVariable es una instancia de la clase Number.

Trabajo con objetos

ActionScript es lo que se denomina un lenguaje de programación orientado a objetos. La programación orientada a objetos es simplemente un enfoque de la programación, es decir, una forma de organizar el código en un programa mediante objetos.

Anteriormente se ha definido un programa informático como una serie de pasos o instrucciones que lleva a cabo el equipo. Así pues, conceptualmente se podría imaginar un programa informático simplemente como una larga lista de instrucciones. Sin embargo, en la programación orientada a objetos, las instrucciones del programa se dividen entre distintos objetos; el código se agrupa en segmentos de funcionalidad, de modo que los tipos de funcionalidad relacionados o los elementos de información relacionados se agrupan en un contenedor.

De hecho, si se ha trabajado con símbolos en Flash, se estará acostumbrado a trabajar con objetos. Supongamos que se ha definido un símbolo de clip de película (por ejemplo, el dibujo de un rectángulo) y se ha colocado una copia del mismo en el escenario. Dicho símbolo de clip de película también es (literalmente) un objeto en ActionScript; es una instancia de la clase MovieClip.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

Es posible modificar algunas de las características del clip de película. Por ejemplo, cuando está seleccionado, es posible cambiar algunos valores en el inspector de propiedades como, por ejemplo, la coordenada x o la anchura, o realizar algunos ajustes de color como cambiar su valor de transparencia alfa o aplicarle un filtro de sombra. Otras herramientas de Flash permiten realizar más cambios, como utilizar la herramienta Transformación libre para girar el rectángulo. Todas estas acciones para modificar un símbolo de clip de película en el entorno de edición de Flash también se pueden realizar en ActionScript cambiando los elementos de datos que se agrupan en un único paquete denominado objeto MovieClip.

En la programación orientada a objetos de ActionScript, hay tres tipos de características que puede contener cualquier clase:

• Propiedades

• Métodos

• Eventos

Estos elementos se utilizan conjuntamente para administrar los elementos de datos que utiliza el programa y para decidir qué acciones deben llevarse a cabo y en qué orden.

Propiedades

Una propiedad representa uno de los elementos de datos que se empaquetan en un objeto. Un objeto Song (canción) puede tener propiedades denominadas

rotation (rotación), x, width (anchura) y alpha (alfa). Se trabaja con las propiedades del mismo modo que con las

variables individuales; de hecho, se podría pensar que las propiedades son simplemente las variables "secundarias" contenidas en un objeto.

artist (artista) y title (título); la clase MovieClip tiene propiedades como

A continuación se muestran algunos ejemplos de código ActionScript que utiliza propiedades. Esta línea de código mueve el objeto MovieClip denominado

square.x = 100;

square a la coordenada x = 100 píxeles:

Este código utiliza la propiedad rotation para que el MovieClip square gire de forma correspondiente a la rotación del MovieClip

square.rotation = triangle.rotation;

triangle:

Este código altera la escala horizontal del MovieClip square para hacerlo 1,5 veces más ancho:

square.scaleX = 1.5;

Fíjese en la estructura común: se utiliza una variable (square, triangle) como nombre del objeto, seguida de un

.) y, a continuación, el nombre de la propiedad (x, rotation, scaleX). El punto, denominado operador de

punto ( punto, se utiliza para indicar el acceso a uno de los elementos secundarios de un objeto. El conjunto de la estructura (nombre de variable-punto-nombre de propiedad) se utiliza como una sola variable, como un nombre de un solo valor en la memoria del equipo.

Métodos

Un método es una acción que puede llevar a cabo un objeto. Por ejemplo, si se ha creado un símbolo de clip de película en Flash con varios fotogramas clave y animación en la línea de tiempo, ese clip de película podrá reproducirse, detenerse o recibir instrucciones para mover la cabeza lectora a un determinado fotograma.

Este código indica al objeto MovieClip denominado

shortFilm que inicie su reproducción:

shortFilm.play();

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

Esta línea hace que el MovieClip denominado shortFilm deje de reproducirse (la cabeza lectora se detiene como si se hiciera una pausa en un vídeo):

shortFilm.stop();

Este código hace que un MovieClip denominado shortFilm mueva su cabeza lectora al fotograma 1 y deje de reproducirse (como si se rebobinara un vídeo):

shortFilm.gotoAndStop(1);

Como puede verse, para acceder a los métodos, se debe escribir el nombre del objeto (una variable), un punto y el nombre del método seguido de un paréntesis, siguiendo la misma estructura que para las propiedades. El paréntesis es una forma de indicar que se está llamando al método, es decir, indicando al objeto que realice esa acción. Algunos valores (o variables) se incluyen dentro del paréntesis para pasar información adicional necesaria para llevar a cabo la acción. Estos valores se denominan parámetros del método. Por ejemplo, el método

gotoAndStop() necesita saber

cuál es el fotograma al que debe dirigirse, de modo que requiere un solo parámetro en el paréntesis. Otros métodos

play() y stop() no requieren información adicional porque son descriptivos por sí mismos. Sin embargo,

como también se escriben con paréntesis.

A diferencia de las propiedades (y las variables), los métodos no se usan como identificadores de valores. No obstante, algunos métodos pueden realizar cálculos y devolver un resultado que puede usarse como una variable. Por ejemplo, el método

toString() de la clase Number convierte el valor numérico en su representación de texto:

var numericData:Number = 9; var textData:String = numericData.toString();

Por ejemplo, se usaría el método toString() para mostrar el valor de una variable Number en un campo de texto de la pantalla. La propiedad

text de la clase TextField (que representa el contenido de texto real que se muestra en la

pantalla) se define como String (cadena), de modo que sólo puede contener valores de texto. Esta línea de código convierte en texto el valor numérico de la variable el objeto TextField denominado

calculatorDisplay.text = numericData.toString();

calculatorDisplay:

numericData y, a continuación, hace que aparezca en la pantalla en

Eventos

Se ha descrito un programa informático como una serie de instrucciones que el ordenador lleva a cabo paso a paso. Algunos programas informáticos sencillos no son más que eso: unos cuantos pasos que el ordenador ejecuta, tras los cuales finaliza el programa. Sin embargo, los programas de ActionScript se han diseñado para continuar ejecutándose, esperando los datos introducidos por el usuario u otras acciones. Los eventos son los mecanismos que determinan qué instrucciones lleva a cabo el ordenador y cuándo las realiza.

Básicamente, los eventos son acciones que ActionScript conoce y a las que puede responder. Muchos eventos se relacionan con la interacción del usuario (hacer clic en un botón, presionar una tecla del teclado, etc.) pero también existen otros tipos de eventos. Por ejemplo, si se usa ActionScript para cargar una imagen externa, existe un evento que puede indicar al usuario cuándo finaliza la carga de la imagen. En esencia, cuando se ejecuta un programa de ActionScript, Adobe Flash Player y Adobe AIR simplemente esperan a que ocurran determinadas acciones y, cuando suceden, ejecutan el código ActionScript que se haya especificado para tales eventos.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

Gestión básica de eventos

La técnica para especificar determinadas acciones que deben realizarse como respuesta a eventos concretos se denomina gestión de eventos. Cuando se escribe código ActionScript para llevar a cabo la gestión de eventos, se deben identificar tres elementos importantes:

• El origen del evento: ¿en qué objeto va a repercutir el evento? Por ejemplo, ¿en qué botón se hará clic o qué objeto

Loader está cargando la imagen? El origen del evento también se denomina objetivo del evento, ya que es el objeto al que Flash Player o AIR destinan el evento (es decir, donde éste tiene lugar realmente).

• El evento: ¿qué va a suceder, a qué se va a responder? Es importante identificar esto porque muchos objetos activan

varios eventos.

• La respuesta: ¿qué pasos hay que llevar a cabo cuando ocurra el evento?

Siempre que se escriba código ActionScript para gestionar eventos, el código debe incluir estos tres elementos y debe seguir esta estructura básica (los elementos en negrita son marcadores de posición que hay que completar en cada caso concreto):

function eventResponse(eventObject:EventType):void { // Actions performed in response to the event go here. }

eventSource.addEventListener(EventType.EVENT_NAME, eventResponse);

Este código realiza dos acciones. En primer lugar, define una función, que es la forma de especificar las acciones que desean realizarse como respuesta al evento. A continuación, llama al método

addEventListener() del objeto de

origen, básicamente "suscribiendo" la función al evento especificado de modo que se lleven a cabo las acciones de la función cuando ocurra el evento. Cada una de estas partes se tratará con mayor detalle.

Una función proporciona un modo de agrupar acciones con un único nombre que viene a ser un nombre de método abreviado para llevar a cabo las acciones. Una función es idéntica a un método excepto en que no está necesariamente asociada a una clase determinada (de hecho, es posible definir un método como una función asociada a una clase determinada). Cuando se crea una función para la gestión de eventos, se debe elegir el nombre de la función (denominada

eventResponse en este caso). Además, se debe especificar un parámetro (denominado eventObject

en este ejemplo). Especificar un parámetro de una función equivale a declarar una variable, de modo que también hay que indicar el tipo de datos del parámetro. (En este ejemplo, el tipo de datos del parámetro es

EventType.)

Cada tipo de evento que se desee detectar tiene asociada una clase de ActionScript. El tipo de datos especificado para el parámetro de función es siempre la clase asociada del evento concreto al que se desea responder. Por ejemplo, un

click (el cual se activa al hacer clic en un elemento con el ratón) se asocia a la clase MouseEvent. Cuando se

evento vaya a escribir una función de detector para un evento datos MouseEvent. Por último, entre las llaves de apertura y cierre (

click, ésta se debe definir con un parámetro con el tipo de

{ ... }), se escriben las instrucciones que debe llevar

a cabo el equipo cuando ocurra el evento.

Después de escribir la función de gestión de eventos, es necesario indicar al objeto de origen del evento (el objeto en el que se produce el evento, por ejemplo, el botón) que se desea llamar a la función cuando ocurra el evento. Para ello es necesario llamar al método tienen un método

addEventListener()). El método addEventListener() utiliza dos parámetros:

addEventListener() de dicho objeto (todos los objetos que tienen eventos también

• En primer lugar, el nombre del evento específico al que se desea responder. De nuevo, cada evento se asocia a una

clase específica, que tiene a su vez un valor especial predefinido para cada evento (como un nombre exclusivo propio del evento), que debe usarse como primer parámetro.

• En segundo lugar, el nombre de la función de respuesta al evento. Hay que tener en cuenta que el nombre de una

función debe escribirse sin paréntesis cuando se pasa como un parámetro.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

Análisis del proceso de gestión de eventos

A continuación se ofrece una descripción paso a paso del proceso que tiene lugar cuando se crea un detector de eventos. En este caso, es un ejemplo de creación de función de detector a la que se llama cuando se hace clic en un objeto denominado

El código escrito por el programador es el siguiente:

function eventResponse(event:MouseEvent):void { // Actions performed in response to the event go here. }

myButton.addEventListener(MouseEvent.CLICK, eventResponse);

Al ejecutarse en Flash Player, el código funcionaría de la manera siguiente. (El comportamiento es idéntico en Adobe AIR):

1 Cuando se carga el archivo SWF, Flash Player detecta que existe una función denominada eventResponse().

myButton.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

2 A continuación, Flash Player ejecuta el código (específicamente, las líneas de código que no están en una función).

En este caso se trata de una sola línea de código: para llamar al método del evento (denominado

myButton) y pasar la función eventResponse como parámetro.

addEventListener() en el objeto de origen

a Internamente, myButton tiene una lista de funciones que detecta cada uno de sus eventos, por lo que cuando se

llama a su método

addEventListener(), myButton almacena la función eventResponse() en su lista de

detectores de eventos.

3 Cuando el usuario hace clic en el objeto myButton, se activa el evento click (identificado como

MouseEvent.CLICK en el código).

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

En este punto ocurre lo siguiente:

a Flash Player crea un objeto, una instancia de la clase asociada con el evento en cuestión (MouseEvent en este

ejemplo). Para muchos eventos esto será una instancia de la clase Event, para eventos del ratón será una instancia de MouseEvent y para otros eventos será una instancia de la clase asociada con el evento. Este objeto creado se conoce como el objeto de evento y contiene información específica sobre el evento que se ha producido: el tipo de evento, el momento en que ha ocurrido y otros datos relacionados con el evento, si procede.

b A continuación, Flash Player busca en la lista de detectores de eventos almacenada en myButton. Recorre estas

funciones de una en una, llamando a cada función y pasando el objeto de evento a la función como parámetro. Como la función Player llama a la función

eventResponse() es uno de los detectores de myButton, como parte de este proceso Flash

eventResponse().

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

c Cuando se llama a la función eventResponse(), se ejecuta el código de la función para realizar las acciones

especificadas.

Ejemplos de gestión de eventos

A continuación se ofrecen más ejemplos concretos de eventos para proporcionar una idea de algunos de los elementos comunes de los eventos y de las posibles variaciones disponibles cuando se escribe código de gestión de eventos:

• Hacer clic en un botón para iniciar la reproducción del clip de película actual. En el siguiente ejemplo, playButton

es el nombre de instancia del botón y

this.stop();

function playMovie(event:MouseEvent):void { this.play(); }

playButton.addEventListener(MouseEvent.CLICK, playMovie);

this es el nombre especial, que significa "el objeto actual":

• Detectar si se ha escrito algo en un campo de texto. En este ejemplo, entryText es un campo de introducción de

outputText es un campo de texto dinámico:

texto y

function updateOutput(event:TextEvent):void { var pressedKey:String = event.text; outputText.text = "You typed: " + pressedKey; }

entryText.addEventListener(TextEvent.TEXT_INPUT, updateOutput);

• Hacer clic en un botón para navegar a un URL. En este caso, linkButton es el nombre de instancia del botón:

function gotoAdobeSite(event:MouseEvent):void { var adobeURL:URLRequest = new URLRequest("http://www.adobe.com/"); navigateToURL(adobeURL); }

linkButton.addEventListener(MouseEvent.CLICK, gotoAdobeSite);

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

Creación de instancias de objetos

Por supuesto, antes de poder utilizar un objeto en ActionScript, éste debe existir. Una parte de la creación de un objeto es la declaración de una variable; sin embargo, declarar una variable sólo crea un espacio vacío en la memoria del equipo. Es necesario asignar un valor real a la variable, es decir, crear un objeto y almacenarlo en la variable, antes de intentar usarla o manipularla. El proceso de creación de un objeto se denomina creación de una instancia del objeto, en concreto, de una clase determinada.

Hay una forma sencilla de crear una instancia de objeto en la que no se utiliza ActionScript en absoluto. En Flash, cuando se coloca un símbolo de clip de película, un símbolo de botón o un campo de texto en el escenario, y se le asigna un nombre de instancia en el inspector de propiedades, Flash declara automáticamente una variable con ese nombre de instancia, crea una instancia de objeto y almacena el objeto en la variable. Del mismo modo, en Adobe Flex Builder, cuando se crea un componente en MXML (codificando una etiqueta MXML o colocando el componente en el editor en modo de diseño) y se le asigna un ID (en el formato MXML o en la vista Propiedades de Flex), ese ID se convierte en el nombre de una variable de ActionScript y se crea una instancia del componente, que se almacena en la variable.

Sin embargo, no siempre se desea crear un objeto visualmente. Hay varias formas de crear instancias de objetos utilizando exclusivamente ActionScript. En primer lugar, con varios tipos de datos de ActionScript, es posible crear una instancia con una expresión literal, es decir, un valor escrito directamente en el código ActionScript. A continuación se muestran algunos ejemplos:

• Valor numérico literal (introducir el número directamente):

var someNumber:Number = 17.239; var someNegativeInteger:int = -53; var someUint:uint = 22;

• Valor de cadena literal (poner el texto entre comillas dobles):

var firstName:String = "George"; var soliloquy:String = "To be or not to be, that is the question...";

• Valor booleano literal (usar los valores literales true o false):

var niceWeather:Boolean = true; var playingOutside:Boolean = false;

• Valor de conjunto literal (cerrar entre corchetes una lista de valores separados por coma):

var seasons:Array = ["spring", "summer", "autumn", "winter"];

• Valor XML literal (introducir los datos XML directamente):

var employee:XML = <employee> <firstName>Harold</firstName> <lastName>Webster</lastName> </employee>;

ActionScript también define expresiones literales para los tipos de datos Array, RegExp, Object y Function. Para obtener información detallada sobre estas clases, consulte “Trabajo con conjuntos” en la página 159, “Utilización de

expresiones regulares” en la página 211 y “Tipo de datos Object” en la página 61.

En los demás tipos de datos, para crear una instancia de objeto, se utiliza el operador

new con el nombre de clase, como

en el siguiente ejemplo:

var raceCar:MovieClip = new MovieClip(); var birthday:Date = new Date(2006, 7, 9);

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

A menudo se hace referencia a la creación de un objeto con el operador new como "llamar al constructor de la clase". Un constructor es un método especial al que se llama como parte del proceso de creación de una instancia de una clase. Debe tenerse en cuenta que, cuando se crea una instancia de este modo, se ponen paréntesis después del nombre de la clase y en ocasiones se especifican los valores del parámetro, dos cosas que también se realizan cuando se llama a un método.

Tenga en cuenta que, incluso en los tipos de datos que permiten crear instancias con una expresión literal, se puede utilizar el operador

new para crear una instancia de objeto. Por ejemplo, las siguientes dos líneas de código realizan

exactamente lo mismo:

var someNumber:Number = 6.33; var someNumber:Number = new Number(6.33);

Es importante familiarizarse con la creación de objetos mediante new ClassName(). Si se necesita crear una instancia de cualquier tipo de datos de ActionScript que no tenga una representación visual (y que, por lo tanto, no pueda crearse colocando un elemento en el escenario de Flash o el modo de diseño del editor MXML de Flex Builder), sólo puede hacerse creando el objeto directamente en ActionScript con el operador

new.

En Flash concretamente, el operador

new también se puede usar para crear una instancia de un símbolo de clip de

película que esté definido en la biblioteca pero no esté colocado en el escenario. Para obtener más información al respecto, consulte “Creación de objetos MovieClip con ActionScript” en la página 422.

Elementos comunes de los programas

Además de la declaración de variables, la creación de instancias de objetos y la manipulación de objetos mediante sus propiedades y métodos, hay otros bloques de creación que se pueden usar para crear un programa de ActionScript.

Operadores

Los operadores son símbolos especiales (o, en ocasiones, palabras) que se utilizan para realizar cálculos. Se utilizan principalmente en las operaciones matemáticas, pero también en la comparación entre valores. Por lo general, un operador utiliza uno o varios valores, y calcula un solo resultado. Por ejemplo:

• El operador de suma (+) suma dos valores y obtiene como resultado una sola cifra:

var sum:Number = 23 + 32;

• El operador de multiplicación (*) multiplica un valor por otro y obtiene como resultado una sola cifra:

var energy:Number = mass * speedOfLight * speedOfLight;

• El operador de igualdad (==) compara dos valores para ver si son iguales y obtiene como resultado un solo valor

booleano (true o false):

if (dayOfWeek == "Wednesday") { takeOutTrash(); }

Como se muestra aquí, el operador de igualdad y los otros operadores de comparación se suelen utilizar con la sentencia

if para determinar si determinadas instrucciones deben llevarse a cabo o no.

Para ver más detalles y ejemplos sobre el uso de los operadores, consulte “Operadores” en la página 71.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

Comentarios

Mientras se escribe código ActionScript, a menudo se desea dejar notas para uno mismo, quizás para explicar el funcionamiento de algunas líneas de código o el motivo de una determinada elección. Los comentarios del código son una herramienta que permite escribir en el código texto que el ordenador debe ignorar. ActionScript incluye dos tipos de comentarios:

• Comentario de una sola línea: un comentario de una sola línea se indica mediante dos barras diagonales en

cualquier lugar de una línea. El ordenador omitirá el texto entre las dos barras y el final de la línea:

// This is a comment; it's ignored by the computer. var age:Number = 10; // Set the age to 10 by default.

• Comentario multilínea: un comentario multilínea contiene un marcador de inicio del comentario (/*), el

contenido del comentario y un marcador de fin del comentario ( y de fin será omitido por el ordenador, independientemente del número de líneas que ocupe el comentario:

/* This might be a really long description, perhaps describing what a particular function is used for or explaining a section of code.

In any case, these lines are all ignored by the computer. */

*/). Todo el texto entre los marcadores de inicio

Los comentarios también se utilizan con frecuencia para "desactivar" una o varias líneas de código. Por ejemplo, si se está probando una forma distinta de llevar a cabo algo o se está intentando saber por qué determinado código ActionScript no funciona del modo esperado.

Control de flujo

En un programa, muchas veces se desea repetir determinadas acciones, realizar sólo algunas acciones y no otras, o realizar acciones alternativas en función de determinadas condiciones, etc. El control de flujo es el control sobre el cual se llevan a cabo las funciones. Hay varios tipos de elementos de control de flujo disponibles en ActionScript.

• Funciones: las funciones son como los métodos abreviados; proporcionan un modo de agrupar una serie de

acciones bajo un solo nombre y pueden utilizarse para realizar cálculos. Las funciones son especialmente importantes en la gestión de eventos, pero también se utilizan como una herramienta general para agrupar una serie de instrucciones. Para obtener más información sobre funciones, consulte “Funciones” en la página 81.

• Bucles: las estructuras de bucle permiten designar una serie de instrucciones que el equipo realizará un número

definido de veces o hasta que cambie alguna condición. A menudo los bucles se utilizan para manipular varios elementos relacionados, mediante una variable cuyo valor cambia cada vez que el ordenador recorre el bucle. Para obtener más información sobre bucles, consulte “Reproducir indefinidamente” en la página 79.

• Sentencias condicionales: las sentencias condicionales proporcionan un modo de designar determinadas

instrucciones que sólo se llevan a cabo bajo circunstancias concretas o de ofrecer conjuntos alternativos de instrucciones para condiciones distintas. El tipo más común de sentencia condicional es la sentencia sentencia

if comprueba un valor o una expresión escrita entre paréntesis. Si el valor es true, se ejecutan las líneas

de código entre llaves; de lo contrario, se omiten. Por ejemplo:

if (age < 20) { // show special teenager-targeted content }

if. La

La pareja de la sentencia if, la sentencia else, permite designar instrucciones alternativas que se llevarán a cabo si la condición no es

true:

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

if (username == "admin") { // do some administrator-only things, like showing extra options } else { // do some non-administrator things }

Para obtener más información sobre sentencias condicionales, consulte “Condicionales” en la página 77.

Ejemplo: Sitio de muestras de animación

Este ejemplo se ha diseñado para ofrecer una primera oportunidad de consultar cómo se pueden juntar fragmentos de ActionScript para crear una aplicación completa llena de código ActionScript. El ejemplo del sitio de muestras de animación es un ejemplo de cómo se puede partir de una animación lineal (por ejemplo, un trabajo creado para un cliente) y añadir algunos elementos interactivos secundarios adecuados para incorporar la animación en un sitio de muestras en línea. El comportamiento interactivo que añadiremos a la animación incluirá dos botones en los que el espectador podrá hacer clic: uno para iniciar la animación y otro para navegar a un URL diferente (como el menú del sitio o la página principal del autor).

El proceso de crear este trabajo puede dividirse en las siguientes partes principales:

1 Preparar el archivo FLA para añadir código ActionScript y elementos interactivos.

2 Crear y añadir los botones.

3 Escribir el código ActionScript.

4 Probar la aplicación.

Preparación de la animación para añadirle interactividad

Para poder añadir elementos interactivos a la animación, es útil configurar el archivo FLA creando algunos lugares para añadir el contenido nuevo. Esto incluye la creación en el escenario del espacio en el que se colocarán los botones y la creación de "espacio" en el archivo FLA para mantener separados los distintos elementos.

Para preparar el archivo FLA para añadir elementos interactivos:

1 Si no dispone de una animación lineal a la que añadir interactividad, cree un nuevo archivo FLA con una animación

sencilla, como una interpolación de movimiento o de forma individual. Si no, abra el archivo FLA que contiene la animación que va a exhibir en el proyecto y guárdela con un nuevo nombre para crear un nuevo archivo de trabajo.

2 Decida en qué parte de la pantalla van a aparecer los dos botones (uno para iniciar la animación y otro vinculado

al sitio de muestras o a la página principal del autor). Si es necesario, borre o añada espacio en el escenario para el nuevo contenido. Si la animación no incluye una pantalla de bienvenida, puede que desee crear una en el primer fotograma (probablemente tenga que desplazar la animación de forma que empiece en el Fotograma 2 o en un fotograma posterior).

3 Añada una nueva capa sobre las otras capas de la línea de tiempo y asigne el nombre buttons. Ésta será la capa a la

que añadirá los botones.

4 Añada otra capa sobre la capa buttons y asígnele el nombre actions. Ésta será la capa en la que añadirá el código

ActionScript para la aplicación.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

Crear y añadir botones

A continuación hay que crear y colocar los botones que forman el centro de la aplicación interactiva.

Para crear y añadir botones al archivo FLA:

1 Utilice las herramientas de dibujo para crear el aspecto visual del primer botón (el botón "play") en la capa buttons.

Por ejemplo, puede dibujar un óvalo horizontal con texto encima.

2 Con la herramienta Selección, seleccione todos los elementos gráficos del botón individual.

3 En el menú principal, elija Modificar > Convertir en símbolo.

4 En el cuadro de diálogo, elija Botón como tipo de símbolo, asigne un nombre al símbolo y haga clic en Aceptar.

5 Con el botón seleccionado, asigne al botón el nombre de instancia playButton en el inspector de propiedades.

6 Repita los pasos 1 a 5 para crear el botón que llevará al usuario a la página principal del autor. Asigne a este botón

el nombre homeButton.

Escritura del código

El código ActionScript para esta aplicación puede dividirse en tres grupos de funcionalidad, aunque se escribirá todo en el mismo lugar. Las tres tareas que el código debe realizar son:

• Detener la cabeza lectora en cuanto se cargue el archivo SWF (cuando la cabeza lectora llegue al Fotograma 1).

• Detectar un evento para iniciar la reproducción del archivo SWF cuando el usuario haga clic en el botón play.

• Detectar un evento para enviar el navegador al URL apropiado cuando el usuario haga clic en el botón vinculado a

la página de inicio del autor.

Para crear el código necesario para detener la cabeza lectora cuando llegue al Fotograma 1:

1 Seleccione el fotograma clave en el Fotograma 1 de la capa actions.

2 Para abrir el panel Acciones, en el menú principal, elija Ventana > Acciones.

3 En el panel Script, escriba el código siguiente:

stop();

Para escribir código para iniciar la animación cuando se haga clic en el botón play:

1 Al final del código escrito en los pasos anteriores, añada dos líneas vacías.

2 Escriba el código siguiente al final del script:

function startMovie(event:MouseEvent):void { this.play(); }

Este código define una función denominada startMovie(). Cuando se llama a startMovie(), hace que se inicie la reproducción de la línea de tiempo principal.

3 En la línea que sigue al código añadido en el paso anterior, escriba esta línea de código:

playButton.addEventListener(MouseEvent.CLICK, startMovie);

Esta línea de código registra la función startMovie() como un detector del evento click de playButton. Es decir, hace que siempre que se haga clic en el botón

playButton, se llame a la función startMovie().

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

Para escribir código que envíe el navegador a una dirección URL cuando se haga clic en el botón vinculado a la página principal:

1 Al final del código escrito en los pasos anteriores, añada dos líneas vacías.

2 Escriba el código siguiente al final del script:

function gotoAuthorPage(event:MouseEvent):void { var targetURL:URLRequest = new URLRequest("http://example.com/"); navigateToURL(targetURL); }

Este código define una función denominada gotoAuthorPage(). Esta función crea primero una instancia de URLRequest que representa el URL http://example.com/ y, a continuación, pasa el URL a la función

navigateToURL(), lo que hace que el navegador del usuario abra dicho URL.

3 En la línea que sigue al código añadido en el paso anterior, escriba esta línea de código:

homeButton.addEventListener(MouseEvent.CLICK, gotoAuthorPage);

Esta línea de código registra la función gotoAuthorPage() como un detector del evento click de homeButton. Es decir, hace que siempre que se haga clic en el botón

homeButton, se llame a la función gotoAuthorPage().

Probar la aplicación

Al llegar a este punto, la aplicación ya debe ser completamente funcional. Pruébela.

Para probar la aplicación:

1 En el menú principal, elija Control > Probar película. Flash crea el archivo SWF y lo abre en una ventana de Flash

Player.

2 Pruebe ambos botones para asegurarse de que funcionan correctamente.

3 Si los botones no funcionan, puede comprobar lo siguiente:

• ¿Tienen los botones nombres de instancia distintos?

• ¿Las llamadas al método addEventListener() utilizan los mismos nombres que los nombres de instancia de

los botones?

• ¿Se utilizan los nombres de evento correctos en las llamadas al método addEventListener()?

• ¿Se ha especificado el parámetro correcto para cada una de las funciones? (Ambos deben tener un solo

parámetro con el tipo de datos MouseEvent.)

Estos errores, y otros errores posibles, deben producir un mensaje de error cuando se elija el comando Probar película o cuando se haga clic en el botón. Vea si hay errores de compilador en el panel Errores del compilador (los que se producen al elegir Probar película) y si hay errores de tiempo de ejecución en el panel Salida (errores que se producen durante la reproducción del archivo SWF, como al hacer clic en un botón).

Creación de aplicaciones con ActionScript

El proceso de escritura de ActionScript para crear una aplicación implica algo más que el simple conocimiento de la sintaxis y los nombres de las clases que se van a utilizar. Si bien la mayor parte de la información de este manual está enfocada hacia esos dos temas (la sintaxis y la utilización de las clases de ActionScript), también es importante saber qué programas se pueden usar para escribir ActionScript, cómo puede organizarse e incluirse el código ActionScript en una aplicación y qué pasos hay que seguir para desarrollar una aplicación ActionScript.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

Opciones para organizar el código

Se puede utilizar código ActionScript 3.0 para crear desde sencillas animaciones gráficas hasta complejos sistemas de procesamiento de transacciones cliente-servidor. Dependiendo del tipo de aplicación que se cree, se preferirá usar una o varias de las siguientes formas posibles de incluir código ActionScript en un proyecto.

Almacenamiento de código en fotogramas de una línea de tiempo de Flash

En el entorno de edición de Flash, es posible añadir código ActionScript a cualquier fotograma de una línea de tiempo. Este código se ejecutará mientras se reproduce la película, cuando la cabeza lectora alcance dicho fotograma.

La colocación del código ActionScript en fotogramas es una forma sencilla de añadir comportamientos a las aplicaciones incorporadas en la herramienta de edición de Flash. Se puede añadir código a cualquier fotograma de la línea de tiempo principal o a cualquier fotograma de la línea de tiempo de cualquier símbolo MovieClip. No obstante, esta flexibilidad tiene un coste. Cuando se crean aplicaciones de mayor tamaño, es fácil perder el rastro de los scripts contenidos en cada fotograma. Con el tiempo, esto puede dificultar el mantenimiento de la aplicación.

Muchos desarrolladores, para simplificar la organización de su código ActionScript en el entorno de edición de Flash, incluyen código únicamente en el primer fotograma de una línea de tiempo o en una capa específica del documento de Flash. De esta forma resulta más sencillo localizar y mantener el código en los archivos FLA de Flash. Sin embargo, para utilizar el mismo código en otro proyecto de Flash, es necesario copiar y pegar el código en el nuevo archivo.

Si desea poder reutilizar el código ActionScript en futuros proyectos de Flash, es recomendable almacenar el código en archivos de ActionScript externos (archivos de texto con la extensión .as).

Almacenamiento de código en archivos de ActionScript

Si el proyecto contiene una cantidad importante de código ActionScript, la mejor forma de organizar el código es en archivos de código fuente ActionScript independientes (archivos de texto con la extensión .as). Un archivo de ActionScript puede estructurarse de una o dos formas, dependiendo del uso que se le quiera dar en la aplicación.

• Código ActionScript no estructurado: líneas de código ActionScript, incluidas sentencias o definiciones de

funciones, escritas como si se introdujeran directamente en un script de la línea de tiempo, un archivo MXML, etc.

Para acceder al código ActionScript escrito de este modo, es preciso utilizar la sentencia o la etiqueta

<mx:Script> en Adobe MXML de Flex. La sentencia include de ActionScript hace que el contenido

include en ActionScript

de un archivo de ActionScript externo se inserte en una ubicación específica y en un ámbito determinado de un script, como si se introdujera allí directamente. En el lenguaje MXML de Flex, la etiqueta

<mx:Script> permite

especificar un atributo de origen que identifica un archivo de ActionScript externo que se cargará en ese punto de la aplicación. Por ejemplo, la siguiente etiqueta cargará un archivo de ActionScript externo denominado Box.as:

<mx:Script source="Box.as" />

• Definición de clase de ActionScript: definición de una clase de ActionScript, incluidas sus definiciones de métodos

y propiedades.

Cuando se define una clase, para obtener acceso al código ActionScript de la clase, se puede crear una instancia de la clase y utilizar sus propiedades, métodos y eventos, tal y como se haría con cualquiera de las clases de ActionScript incorporadas. Esto se realiza en dos partes:

• Utilizar la sentencia import para especificar el nombre completo de la clase, de modo que el compilador de

ActionScript sepa dónde encontrarlo. Por ejemplo, si se desea utilizar la clase MovieClip en ActionScript, primero se debe importar esa clase con su nombre completo, incluido el paquete y la clase:

import flash.display.MovieClip;

Como alternativa, se puede importar el paquete que contiene la clase MovieClip, que equivale a escribir sentencias

import independientes para cada clase del paquete:

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

import flash.display.*;

Las únicas excepciones a la regla que dicta que una clase debe importarse si se hace referencia a ella en el código son las clases de nivel superior, que no se definen en un paquete.

Nota: en Flash, las clases incorporadas (en los paquetes flash.*) se importan automáticamente en los scripts adjuntos a fotogramas de la línea de tiempo. Sin embargo, cuando se escriben clases propias o si se trabaja con los componentes de edición de Flash (los paquetes fl.*) o se trabaja en Flex, será necesario importar de forma explícita cualquier clase para poder escribir código que cree instancias de dicha clase.

• Escribir código referido específicamente al nombre de clase (normalmente declarando una variable con esa clase

como tipo de datos y creando una instancia de la clase para almacenarla en la variable). Al hacer referencia a otro nombre de clase en el código ActionScript, se indica al compilador que cargue la definición de dicha clase. Si se toma como ejemplo una clase externa denominada Box, esta sentencia provoca la creación de una nueva instancia de la clase Box:

var smallBox:Box = new Box(10,20);

Cuando el compilador se encuentra con la referencia a la clase Box por primera vez, busca el código fuente cargado para localizar la definición de la clase Box.

Selección de la herramienta adecuada

En función de las necesidades del proyecto y de los recursos disponibles, se puede utilizar una de las herramientas (o varias herramientas conjuntas) para escribir y editar el código ActionScript.

Herramienta de edición de Flash

Además de las capacidades de creación de animación y gráficos, Adobe Flash CS4 Professional incluye herramientas para trabajar con código ActionScript, ya sea asociado a los elementos de un archivo FLA como a archivos externos que sólo contienen código ActionScript. La herramienta de edición de Flash es ideal para los proyectos que contienen una cantidad importante de animación o vídeo, o los proyectos donde el usuario desea crear la mayoría de los activos gráficos, concretamente los proyectos con una mínima interacción del usuario o funcionalidad que requiera ActionScript. Otro motivo para elegir la herramienta de edición de Flash para desarrollar los proyectos de ActionScript es que se prefiera crear activos visuales y escribir código en la misma aplicación. Quizá también se prefiera usar la herramienta de edición de Flash si se van a utilizar componentes de interfaz de usuario creados previamente, pero las prioridades básicas del proyecto sean reducir el tamaño de los archivos SWF o facilitar la aplicación de aspectos visuales.

Adobe Flash CS4 Professional incluye dos herramientas para escribir código ActionScript:

• Panel Acciones: este panel, disponible cuando se trabaja en un archivo FLA, permite escribir código ActionScript

asociado a los fotogramas de una línea de tiempo.

• Ventana Script: la ventana Script es un editor de texto dedicado para trabajar con archivos de código ActionScript

(.as).

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

Flex Builder

Adobe Flex Builder es la principal herramienta para crear proyectos con la arquitectura Flex. Además de sus herramientas de edición de MXML y diseño visual, Flex Builder incluye un editor de ActionScript completo, de modo que puede usarse para crear proyectos de Flex o sólo de ActionScript. Las aplicaciones Flex presentan varias ventajas, como un amplio conjunto de controles de interfaz de usuario predefinidos, controles de diseño dinámicos y flexibles, y mecanismos incorporados para trabajar con orígenes de datos externos y vincular datos externos con elementos de interfaz de usuario. Sin embargo, debido al código adicional necesario para proporcionar estas funciones, las aplicaciones Flex pueden tener un tamaño de archivo SWF más grande y presentan una mayor dificultad que sus equivalentes de Flash a la hora de cambiar completamente los aspectos aplicados.

Se recomienda usar Flex Builder para crear con Flex complejas y completas aplicaciones para Internet basadas en datos, y para editar código ActionScript, editar código MXML y diseñar visualmente la aplicación con una sola herramienta.

Editor de ActionScript de terceros

Dado que los archivos ActionScript (.as) se almacenan como archivos de texto sencillo, cualquier programa que sea capaz de editar archivos de texto simple se puede usar para escribir archivos ActionScript. Además de los productos ActionScript de Adobe, se han creado varios programas de edición de texto de terceros con funciones específicas de ActionScript. Se pueden escribir archivos MXML o clases de ActionScript con cualquier programa editor de texto. A partir de estos archivos, se puede crear una aplicación SWF (ya sea una aplicación Flex o sólo de ActionScript) con la ayuda del SDK de Flex, que incluye las clases de la arquitectura Flex además del compilador Flex. Como alternativa, muchos desarrolladores utilizan un editor de ActionScript de terceros para escribir las clases de ActionScript y la herramienta de edición de Flash para crear el contenido gráfico.

El usuario puede optar por utilizar un editor de ActionScript de terceros si:

• Prefiere escribir código ActionScript en un programa independiente y diseñar los elementos visuales en Flash.

• Utiliza una aplicación para programar con un lenguaje distinto de ActionScript (por ejemplo, para crear páginas

HTML o aplicaciones en otro lenguaje de programación) y desea usar la misma aplicación para el código ActionScript.

• Desea crear proyectos de Flex o sólo de ActionScript con el SDK de Flex, sin tener que utilizar Flash o Flex Builder.

Entre los editores de código que proporcionan funciones específicas de ActionScript, cabe destacar:

• Adobe Dreamweaver® CS4

• ASDT

• FDT

• FlashDevelop

• PrimalScript

• SE|PY

Proceso de desarrollo de ActionScript

Independientemente del tamaño del proyecto de ActionScript, la utilización de un proceso para diseñar y desarrollar la aplicación permitirá trabajar con mayor eficacia. En los siguientes pasos se describe un proceso de desarrollo básico para crear una aplicación con ActionScript 3.0:

1 Diseñe la aplicación.

Debe describir la aplicación de alguna forma antes de empezar a crearla.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

2 Escriba el código ActionScript 3.0.

Puede crear código ActionScript con Flash, Flex Builder, Dreamweaver o un editor de texto.

3 Cree un archivo de aplicación Flash o Flex para ejecutar el código.

En la herramienta de edición de Flash, esto implica crear un nuevo archivo FLA, establecer la configuración de publicación, añadir componentes de interfaz de usuario a la aplicación y hacer referencia al código ActionScript. En el entorno de desarrollo de Flex, la creación de un nuevo archivo de aplicación implica definir la aplicación, añadir componentes de interfaz de usuario con MXML y hacer referencia al código ActionScript.

4 Publique y pruebe la aplicación ActionScript.

Esto implica ejecutar la aplicación desde la herramienta de edición de Flash o el entorno de desarrollo de Flex, y comprobar que realiza todo lo previsto.

Debe tenerse en cuenta que estos pasos no tienen por qué seguir este orden necesariamente y que tampoco es necesario finalizar completamente uno de los pasos antes de poder trabajar en otro. Por ejemplo, se puede diseñar una pantalla de la aplicación (paso 1) y luego crear los gráficos, botones y otros elementos (paso 3) antes de escribir el código ActionScript (paso 2) y probarlo (paso 4). O bien, se puede realizar parte del diseño y luego añadir un botón o elemento de interfaz en un momento dado, escribir código ActionScript para cada uno de estos elementos y probarlos. Aunque resulta útil recordar estas cuatro fases del proceso de desarrollo, en una situación real suele ser más eficaz ir pasando de una fase a otra según convenga.

Creación de clases personalizadas

El proceso de creación de clases para usarlas en los proyectos puede parecer desalentador. Sin embargo, la tarea más difícil de la creación de una clase es su diseño, es decir, la identificación de los métodos, propiedades y eventos que va a incluir.

Estrategias de diseño de una clase

El tema del diseño orientado a objetos es complejo; algunas personas han dedicado toda su carrera al estudio académico y la práctica profesional de esta disciplina. Sin embargo, a continuación se sugieren algunos enfoques que pueden ayudarle a comenzar.

1 Piense en la función que desempeñarán las instancias de esta clase en la aplicación. Normalmente, los objetos

desempeñan una de estas tres funciones:

• Objeto de valor: estos objetos actúan principalmente como contenedores de datos, es decir, que es probable que

tengan varias propiedades y pocos métodos (o algunas veces ninguno). Normalmente son representaciones de código de elementos claramente definidos, como una clase Song (que representa una sola canción real) o una clase Playlist (que representa un grupo conceptual de canciones) en una aplicación de reproductor de música.

• Objetos de visualización: son objetos que aparecen realmente en la pantalla. Por ejemplo, elementos de interfaz

de usuario como una lista desplegable o una lectura de estado, o elementos gráficos como las criaturas de un videojuego, etc.

• Estructura de aplicación: estos objetos desempeñan una amplia gama de funciones auxiliares en la lógica o el

procesamiento llevado a cabo por las aplicaciones. Algunos ejemplos son: un objeto que realice determinados cálculos en una simulación biológica, un objeto responsable de sincronizar valores entre un control de dial y una lectura de volumen en una aplicación de reproductor de música, uno que administre las reglas de un videojuego u otro que cargue una imagen guardada en una aplicación de dibujo.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

2 Decida la funcionalidad específica que necesitará la clase. Los distintos tipos de funcionalidad suelen convertirse en

los métodos de la clase.

3 Si se prevé que la clase actúe como un objeto de valor, decida los datos que incluirán las instancias. Estos elementos

son buenos candidatos para las propiedades.

4 Dado que la clase se diseña específicamente para el proyecto, lo más importante es proporcionar la funcionalidad

que necesita la aplicación. Quizá le sirva de ayuda formularse estas preguntas:

• ¿Qué elementos de información almacenará, rastreará y manipulará la aplicación? Esta decisión le ayudará a

identificar los posibles objetos de valor y las propiedades.

• ¿Qué conjuntos de acciones deberán realizarse, por ejemplo, al cargar la aplicación por primera vez, al hacer clic

en un botón concreto o al detener la reproducción de una película? Estos serán buenos candidatos para los métodos (o propiedades, si las "acciones" implican simplemente cambiar valores individuales).

• En cualquier acción determinada, ¿qué información necesitará saber la clase para realizar dicha acción? Estos

elementos de información se convierten en los parámetros del método.

• Mientras la aplicación lleva a cabo su trabajo, ¿qué cambiará en la clase que deba ser conocido por las demás

partes de la aplicación? Éstos son buenos candidatos para los eventos.

5 Si ya existe un objeto similar al que necesita, a no ser que carezca de alguna funcionalidad adicional que desee

añadir, considere la posibilidad de crear una subclase (una clase que se basa en la funcionalidad de una clase existente, en lugar de definir toda su propia funcionalidad). Por ejemplo, si desea crear una clase que sea un objeto visual en la pantalla, deseará usar el comportamiento de uno de los objetos de visualización existentes (por ejemplo, Sprite o MovieClip) como base de la clase. En ese caso, MovieClip (o Sprite) sería la clase base y su clase sería una ampliación de dicha clase. Para obtener más información sobre cómo crear una subclase, consulte “Herencia” en la página 111.

Escritura del código de una clase

Cuando ya tenga un plan de diseño para la clase, o al menos alguna idea de la información de la que deberá hacer un seguimiento y de las acciones que necesitará realizar, la sintaxis real de escritura de una clase es bastante directa.

A continuación se describen los pasos mínimos para crear su propia clase de ActionScript:

1 Abra un nuevo documento de texto en un programa específico de ActionScript como Flex Builder o Flash, en una

herramienta de programación general como Dreamweaver o en cualquier programa que permita trabajar con documentos de texto simple.

2 Introduzca una sentencia class para definir el nombre de la clase. Para ello, introduzca las palabras public class

y, a continuación, el nombre de la clase, seguido de llaves de apertura y cierre que rodearán el contenido de la clase (las definiciones de métodos y propiedades). Por ejemplo:

public class MyClass { }

La palabra public indica que es posible acceder a la clase desde cualquier otro código. Para conocer otras alternativas, consulte “Atributos del espacio de nombres de control de acceso” en la página 97.

3 Escriba una sentencia package para indicar el nombre del paquete en el que se encontrará la clase. La sintaxis es la

palabra bloque de sentencias

package, seguida del nombre completo del paquete, seguido de llaves de apertura y cierre (que rodearán el

class). Por ejemplo, se cambiaría el código del paso anterior por el siguiente:

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

package mypackage { public class MyClass { } }

Introducción a ActionScript

4 Defina cada propiedad de la clase con la sentencia var en el cuerpo de la clase; la sintaxis es la misma que se usa

para declarar cualquier variable (añadiendo el modificador paréntesis de apertura y cierre de la definición de clase, se crearán las propiedades

numericVariable y dateVariable:

public var textVariable:String = "some default value"; public var numericVariable:Number = 17; public var dateVariable:Date;

public). Por ejemplo, si se añaden estas líneas entre los

textVariable,

5 Defina cada método de la clase con la misma sintaxis empleada para definir una función. Por ejemplo:

• Para crear un método myMethod(), introduzca:

public function myMethod(param1:String, param2:Number):void { // do something with parameters }

• Para crear un constructor (el método especial al que se llama como parte del proceso de creación de una

instancia de una clase), cree un método cuyo nombre coincida exactamente con el nombre de la clase:

public function MyClass() { // do stuff to set initial values for properties // and otherwise set up the object textVariable = "Hello there!"; dateVariable = new Date(2001, 5, 11); }

Si no incluye un método constructor en la clase, el compilador creará automáticamente un constructor vacío (sin parámetros ni sentencias) en la clase.

Hay algunos otros elementos de la clase que pueden definirse y que son más complicados.

• Los descriptores de acceso son un cruce especial entre un método y una propiedad. Cuando se escribe el código

para definir la clase, el descriptor de acceso se escribe como un método, de forma que es posible realizar varias acciones, en lugar de simplemente leer o asignar un valor, que es todo lo que puede hacerse cuando se define una propiedad. Sin embargo, cuando se crea una instancia de la clase, se trata al descriptor de acceso como una propiedad y sólo se utiliza el nombre para leer o asignar el valor. Para obtener más información, consulte “Métodos descriptores de acceso (captador y definidor)” en la página 104.

• En ActionScript, los eventos no se definen con una sintaxis específica. En lugar de eso, los eventos de la clase se

definen con la funcionalidad de la clase EventDispatcher para realizar un seguimiento de los detectores de eventos y notificarles los eventos. Para obtener más información sobre la creación de eventos en sus propias clases, consulte “Gestión de eventos” en la página 254.

Ejemplo: Creación de una aplicación básica

Es posible crear archivos de código fuente ActionScript externos con una extensión .as utilizando Flash, Flex Builder, Dreamweaver o cualquier editor de texto.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

ActionScript 3.0 puede utilizarse en varios entornos de desarrollo de aplicaciones, como las herramientas de edición de Flash y Flex Builder.

En esta sección se indican los pasos necesarios para crear y mejorar una sencilla aplicación ActionScript 3.0 con la herramienta de edición de Flash o con Flex Builder. La aplicación que se va a crear presenta un patrón sencillo de utilización de archivos de clases de ActionScript 3.0 externos en aplicaciones Flash y Flex. Dicho patrón se utilizará en todas las demás aplicaciones de ejemplo de este manual.

Diseño de una aplicación ActionScript

Debería tener alguna idea de la aplicación que desea crear antes de empezar a crearla.

La representación del diseño puede ser tan sencilla como el nombre de la aplicación y una breve declaración del propósito de la misma o tan complicada como un conjunto de documentos de requisitos con numerosos diagramas de Lenguaje de modelado unificado (UML). Aunque este manual no trata con detalle el tema del diseño de software, es importante recordar que el diseño de la aplicación es un paso fundamental del desarrollo de las aplicaciones ActionScript.

El primer ejemplo de una aplicación ActionScript es una aplicación "Hello World" estándar, de modo que su diseño es muy sencillo:

• La aplicación se denominará HelloWorld.

• Mostrará un solo campo de texto con las palabras "Hello World!".

• Para poder reutilizarla fácilmente, utilizará una sola clase orientada a objetos, denominada Greeter, que puede

usarse desde un documento de Flash o una aplicación Flex.

• Después de crear una versión básica de la aplicación, deberá añadir funcionalidad para que haga que el usuario

introduzca un nombre de usuario y que la aplicación compruebe el nombre en una lista de usuarios conocidos.

Teniendo en cuenta esta definición concisa, ya puede empezar a crear la aplicación.

Creación del proyecto HelloWorld y de la clase Greeter

Según el propósito del diseño de la aplicación Hello World, el código debería poder reutilizarse fácilmente. Teniendo esto en cuenta, la aplicación utiliza una sola clase orientada a objetos, denominada Greeter, que se usa desde una aplicación creada en Flex Builder o la herramienta de edición de Flash.

Para crear la clase Greeter en la herramienta de edición de Flash:

1 En la herramienta de edición de Flash, seleccione Archivo > Nuevo.

2 En el cuadro de diálogo Nuevo documento, seleccione Archivo ActionScript y haga clic en Aceptar.

Aparecerá una nueva ventana de edición de ActionScript.

3 Seleccione Archivo > Guardar. Seleccione la carpeta en la que desea almacenar la aplicación, asigne el nombre

Greeter.as al archivo ActionScript y haga clic en Aceptar.

Para continuar, consulte la sección “Añadir código a la clase Greeter” en la página 31.

Añadir código a la clase Greeter

La clase Greeter define un objeto, Greeter, que podrá utilizar en la aplicación HelloWorld.

Para añadir código a la clase Greeter:

1 Introduzca el código siguiente en el nuevo archivo:

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

package { public class Greeter { public function sayHello():String { var greeting:String; greeting = "Hello World!"; return greeting; } } }

La clase Greeter incluye un único método sayHello(), el cual devuelve una cadena con el texto "Hello World!".

2 Seleccione Archivo > Guardar para guardar este archivo de ActionScript.

Ya se puede utilizar la clase Greeter en la aplicación.

Creación de una aplicación que utilice el código ActionScript

La clase Greeter que ha creado define un conjunto de funciones de software con contenido propio, pero no representa una aplicación completa. Para utilizar la clase, necesita crear un documento de Flash o una aplicación Flex.

La aplicación HelloWorld crea una nueva instancia de la clase Greeter. A continuación se explica cómo asociar la clase Greeter a la aplicación.

Para crear una aplicación ActionScript mediante la herramienta de edición de Flash:

1 Seleccione Archivo > Nuevo.

2 En el cuadro de diálogo Nuevo documento, seleccione Documento de Flash y haga clic en Aceptar.

Aparece una nueva ventana de Flash.

3 Seleccione Archivo > Guardar. Seleccione la misma carpeta que contiene el archivo de clase Greeter.as, asigne al

documento de Flash el nombre HelloWorld.fla y haga clic en Aceptar.

4 En la paleta Herramientas de Flash, seleccione la herramienta Texto y arrastre el cursor por el escenario para definir

un nuevo campo de texto, con una anchura de aproximadamente 300 píxeles y una altura de unos 100 píxeles.

5 En el panel Propiedades, con el campo de texto todavía seleccionado en el escenario, establezca "Texto dinámico"

como tipo de texto y escriba mainText como nombre de instancia del campo de texto.

6 Haga clic en el primer fotograma de la línea de tiempo principal.

7 En el panel Acciones, escriba el siguiente script:

var myGreeter:Greeter = new Greeter(); mainText.text = myGreeter.sayHello();

8 Guarde el archivo.

Para continuar, consulte la sección “Publicación y prueba de la aplicación ActionScript” en la página 32.

Publicación y prueba de la aplicación ActionScript

El desarrollo de software es un proceso repetitivo. Se escribe código, se intenta compilar y se edita hasta que se compile sin problemas. Se ejecuta la aplicación compilada, se prueba para ver si cumple con el diseño previsto y, si no es así, se edita de nuevo el código hasta que lo cumple. Los entornos de desarrollo de Flash y Flex Builder ofrecen diversas formas de publicar, probar y depurar las aplicaciones.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

A continuación se explican los pasos básicos para probar la aplicación HelloWorld en cada entorno.

Para publicar y probar una aplicación ActionScript mediante la herramienta de edición de Flash:

1 Publique la aplicación y vea si aparecen errores de compilación. En la herramienta de edición de Flash, seleccione

Control > Probar película para compilar el código ActionScript y ejecutar la aplicación HelloWorld.

2 Si aparecen errores o advertencias en la ventana Salida al probar la aplicación, corrija las causas de estos errores en

el archivo HelloWorld.fla o HelloWorld.as y pruebe de nuevo la aplicación.

3 Si no se producen errores de compilación, verá una ventana de Flash Player en la que se mostrará la aplicación Hello

World.

Acaba de crear una aplicación orientada a objetos sencilla, pero completa, que utiliza ActionScript 3.0. Para continuar, consulte la sección “Mejora de la aplicación HelloWorld” en la página 33.

Mejora de la aplicación HelloWorld

Para hacer la aplicación un poco más interesante, hará que pida y valide un nombre de usuario en una lista predefinida de nombres.

En primer lugar, deberá actualizar la clase Greeter para añadir funcionalidad nueva. A continuación, actualizará la aplicación para utilizar la nueva funcionalidad.

Para actualizar el archivo Greeter.as:

1 Abra el archivo Greeter.as.

2 Cambie el contenido del archivo por lo siguiente (las líneas nuevas y cambiadas se muestran en negrita):

package { public class Greeter { /** * Defines the names that should receive a proper greeting. */ public static var validNames:Array = ["Sammy", "Frank", "Dean"];

/** * Builds a greeting string using the given name. */ public function sayHello(userName:String = ""):String { var greeting:String; if (userName == "") { greeting = "Hello. Please type your user name, and then press

the Enter key."; } else if (validName(userName)) { greeting = "Hello, " + userName + "."; } else { greeting = "Sorry " + userName + ", you are not on the list.";

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

} return greeting; }

/** * Checks whether a name is in the validNames list. */ public static function validName(inputName:String = ""):Boolean { if (validNames.indexOf(inputName) > -1) { return true; } else { return false; } } } }

La clase Greeter tiene ahora varias funciones nuevas:

Introducción a ActionScript

• El conjunto validNames enumera los nombres de usuario válidos. El conjunto se inicializa como una lista de tres

nombres cuando se carga la clase Greeter.

• El método sayHello() acepta ahora un nombre de usuario y cambia el saludo en función de algunas condiciones.

userName es una cadena vacía (""), la propiedad greeting se define de forma que pida un nombre al usuario.

Si Si el nombre de usuario es válido, el saludo se convierte en alguna de estas dos condiciones, la variable

list".

greeting se define como "Sorry, userName, you are not on the

"Hello, userName". Finalmente, si no se cumple

• El método validName() devuelve true si inputName se encuentra en el conjunto validNames y false si no se

encuentra. La sentencia

validNames con respecto a la cadena inputName. El método Array.indexOf() devuelve la posición de índice de

validNames.indexOf(inputName) comprueba cada una de las cadenas del conjunto

la primera instancia de un objeto en un conjunto o el valor -1 si el objeto no se encuentra en el conjunto.

A continuación editará el archivo de Flash o Flex que hace referencia a esta clase de ActionScript.

Para modificar la aplicación ActionScript mediante la herramienta de edición de Flash:

1 Abra el archivo HelloWorld.fla.

2 Modifique el script en el Fotograma 1 de forma que se pase una cadena vacía ("") al método sayHello() de la clase

Greeter:

var myGreeter:Greeter = new Greeter(); mainText.text = myGreeter.sayHello("");

3 Seleccione la herramienta Texto en la paleta Herramientas y cree dos nuevos campos de texto en el escenario, uno

junto al otro, y debajo del campo de texto

mainText existente.

4 En el primer campo de texto nuevo, escriba User Name: como etiqueta.

5 Seleccione el otro campo de texto nuevo y, en el inspector de propiedades, seleccione InputText como tipo del

campo de texto. Seleccione Línea única como tipo de línea. Escriba textIn como nombre de instancia.

6 Haga clic en el primer fotograma de la línea de tiempo principal.

7 En el panel Acciones, añada las líneas siguientes al final del script existente:

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

mainText.border = true; textIn.border = true;

textIn.addEventListener(KeyboardEvent.KEY_DOWN, keyPressed);

function keyPressed(event:KeyboardEvent):void { if (event.keyCode == Keyboard.ENTER) { mainText.text = myGreeter.sayHello(textIn.text); } }

Introducción a ActionScript

El código nuevo añade la siguiente funcionalidad:

• Las dos primeras líneas sólo definen los bordes de dos campos de texto.

• Un campo de texto de entrada, como el campo textIn, tiene un conjunto de eventos que puede distribuir. El

método

addEventListener() permite definir una función que se ejecuta cuando se produce un tipo de evento.

En este caso, el evento es presionar una tecla del teclado.

• La función personalizada keyPressed() comprueba si la tecla presionada es la tecla Intro. De ser así, llama al

método

sayHello() del objeto myGreeter y le pasa el texto del campo de texto textIn como parámetro. El

método devuelve una cadena de saludo basada en el valor pasado. Después se asigna la cadena devuelta a la propiedad

text del campo de texto mainText.

A continuación se muestra el script completo para el Fotograma 1:

var myGreeter:Greeter = new Greeter(); mainText.text = myGreeter.sayHello("");

mainText.border = true; textIn.border = true;

textIn.addEventListener(KeyboardEvent.KEY_DOWN, keyPressed);

function keyPressed(event:KeyboardEvent):void { if (event.keyCode == Keyboard.ENTER) { mainText.text = myGreeter.sayHello(textIn.text); } }

8 Guarde el archivo.

9 Seleccione Control > Probar película para ejecutar la aplicación.

Cuando ejecute la aplicación se le pedirá que escriba un nombre de usuario. Si es válido (Sammy, Frank o Dean), la aplicación mostrará el mensaje de confirmación "hello".

Ejecución de ejemplos posteriores

Después de desarrollar y ejecutar la aplicación "Hello World" de ActionScript 3.0, debería haber adquirido los conocimientos básicos que necesita para ejecutar los demás ejemplos de código presentados en este manual.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

Prueba de los listados de código de ejemplo del capítulo

A medida que avance en el manual, deseará probar los listados de código de ejemplo con los que se ilustran los distintos temas. Para probarlos puede tener que mostrar el valor de las variables en determinados puntos del programa o bien ver el contenido mostrado en pantalla o interactuar con él. Para las pruebas de contenido visual o de interacción, los elementos necesarios se describirán antes (o dentro) del listado de código; sólo tendrá que crear un documento con los elementos descritos por orden para probar el código. En caso de que desee ver el valor de una variable en un punto determinado del programa, puede hacerlo de varias maneras distintas. Una manera es utilizar un depurador, como los integrados en Flex Builder y en Flash. Sin embargo, para las pruebas sencillas puede ser más fácil simplemente imprimir los valores de las variables en algún lugar en que pueda verlas.

Los pasos siguientes le ayudarán a crear un documento de Flash con el que podrá probar un listado de código y ver valores de las variables:

Para crear un documento de Flash a fin de probar los ejemplos del capítulo:

1 Cree un nuevo documento de Flash y guárdelo en el disco duro.

2 Para mostrar valores de prueba en un campo de texto en el escenario, active la herramienta Texto y cree un nuevo

campo de texto dinámico en el escenario. Le resultará útil tener un campo de texto ancho y alto, con el tipo de línea establecido en Multilínea. En el inspector de propiedades, asigne al campo de texto un nombre de instancia (por ejemplo, "outputText"). Para poder escribir valores en el campo de texto hay que añadir al ejemplo código que llame al método

3 Como alternativa, se puede añadir una llamada a función trace() al listado de código (como se indica más abajo)

para ver los resultados del ejemplo.

4 Para probar un ejemplo determinado, copie el listado de código en el panel Acciones; si es necesario, añada una

llamada a la función

5 En el menú principal, elija Control > Probar película para crear un archivo SWF y ver los resultados.

appendText() (descrito a continuación).

trace() o añada un valor al campo de texto utilizando su método appendText().

Dado que este enfoque se utiliza para ver valores de variables, hay dos formas de consultar fácilmente los valores de las variables conforme se prueban los ejemplos: escribiendo valores en una instancia de campo de texto en el escenario o utilizando la función

trace() para imprimir valores en el panel Salida.

• La función trace() de ActionScript: la función trace() de ActionScript escribe los valores de los parámetros que

recibe (ya sean variables o expresiones literales) en el panel Salida. Muchos de los listados de ejemplo de este manual ya incluyen una llamada a la función documento y probar el proyecto. Si desea utilizar código que no la incluye, sólo tiene que añadir una llamada a

trace(), así que para esos listados sólo tendrá que copiar el código en el

trace() para probar el valor de una variable en un listado de

trace() al listado de código y pasarle la variable como

parámetro. Por ejemplo, si encuentra un listado de código como el de este capítulo,

var albumName:String = "Three for the money";

puede copiar el código en el panel Acciones y añadir una llamada a la función trace() como ésta para probar el resultado del listado de código:

var albumName:String = "Three for the money"; trace("albumName =", albumName);

Si ejecuta el programa, se imprimirá esta línea:

albumName = Three for the money

Cada llamada a la función trace() puede incluir varios parámetros, que se encadenan como una sola línea impresa. Al final de cada llamada a la función función

trace() se imprimirán en líneas distintas.

trace() se añade un salto de línea, por lo que distintas llamadas a la

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

Introducción a ActionScript

• Un campo de texto en el escenario: si prefiere no utilizar la función trace(), puede añadir un campo de texto

dinámico al escenario mediante la herramienta Texto y escribir valores en dicho campo para ver los resultados de un listado de código. Se puede utilizar el método

appendText() de la clase TextField para añadir un valor String

al final del contenido del campo de texto. Para acceder al campo de texto mediante código ActionScript, debe asignarle un nombre de instancia en el inspector de propiedades. Por ejemplo, si el campo de texto tiene el nombre de instancia

var albumName:String = "Three for the money"; outputText.appendText("albumName = "); outputText.appendText(albumName);

outputText, se puede utilizar el código siguiente para comprobar el valor de la variable albumName:

Este código escribirá el texto siguiente en el campo de texto denominado outputText:

albumName = Three for the money

Como muestra el ejemplo, el método appendText() añadirá el texto a la misma línea que el contenido anterior, por lo que se pueden añadir varias líneas a la misma línea de texto mediante varias llamadas a forzar que el texto pase a la siguiente línea, puede añadir un carácter de nueva línea (

outputText.appendText("\n"); // adds a line break to the text field

"\n"):

appendText(). Para

A diferencia de la función trace(), el método appendText() sólo acepta un valor como parámetro. Dicho valor debe ser una cadena (una instancia de String o un literal de cadena). Para imprimir el valor de una variable que no sea de tipo cadena, primero debe convertir el valor en una cadena. La forma más sencilla de hacer esto es llamar al método

toString() del objeto:

var albumYear:int = 1999; outputText.appendText("albumYear = "); outputText.appendText(albumYear.toString());

Ejemplos de final de capítulo

Al igual que este capítulo, la mayoría de los capítulos incluyen un ejemplo ilustrativo de fin de capítulo que relaciona muchos de los conceptos descritos. Sin embargo, a diferencia del ejemplo Hello World de este capítulo, los ejemplos no se presentarán en un formato de tutorial paso a paso. Se resaltará y explicará el código ActionScript 3.0 relevante de cada ejemplo, pero no se ofrecerán instrucciones para ejecutar los ejemplos en entornos de desarrollo específicos. Sin embargo, los archivos de ejemplo distribuidos con este manual incluirán todos los archivos necesarios para compilar fácilmente los ejemplos en el entorno de desarrollo elegido.

Capítulo 4: El lenguaje ActionScript y su sintaxis

ActionScript 3.0 consta del lenguaje ActionScript y la interfaz de programación de aplicaciones (API) de Adobe Flash Player. El lenguaje principal es la parte de ActionScript que define la sintaxis del lenguaje, así como los tipos de datos de nivel superior. ActionScript 3.0 proporciona acceso programado a Flash Player.

Este capítulo ofrece una breve introducción al lenguaje ActionScript y su sintaxis. Su lectura proporciona conocimientos básicos sobre cómo trabajar con tipos de datos y variables, utilizar la sintaxis correcta y controlar el flujo de datos de un programa.

Información general sobre el lenguaje

Los objetos constituyen la base del lenguaje ActionScript 3.0. Son sus componentes esenciales. Cada variable que se declare, cada función que se escriba y cada instancia de clase que se cree es un objeto. Se puede considerar que un programa ActionScript 3.0 es un grupo de objetos que realizan tareas, responden a eventos y se comunican entre sí.

Para los programadores que están familiarizados con la programación orientada a objetos (OOP) en Java o C++ los objetos son módulos que contienen dos tipos de miembros: datos almacenados en variables o propiedades miembro, y comportamiento al que se puede acceder a través de métodos. ActionScript 3.0 define los objetos de forma similar, aunque ligeramente distinta. En ActionScript 3.0, los objetos son simplemente colecciones de propiedades. Estas propiedades son contenedores que pueden contener no sólo datos, sino también funciones u otros objetos. Si se asocia una función a un objeto de esta manera, la función se denomina método.

Aunque la definición de ActionScript 3.0 puede parecer extraña a los programadores con experiencia en programación con Java o C++, en la práctica, la definición de tipos de objetos con clases de ActionScript 3.0 es muy similar a la manera de definir clases en Java o C++. La distinción entre las dos definiciones de objeto es importante al describir el modelo de objetos de ActionScript y otros temas avanzados, pero en la mayoría de las demás situaciones, el término propiedades se refiere a variables miembro de clase, no a métodos. La Referencia del lenguaje y componentes ActionScript 3.0 utiliza, por ejemplo, el término propiedades para hacer referencia a variables o propiedades de captores y definidores. El término métodos se utiliza para designar funciones que forman parte de una clase.

Una diferencia sutil entre las clases de ActionScript y las clases de Java o C++ es que, en ActionScript, las clases no son sólo entidades abstractas. Las clases de ActionScript se representan mediante objetos de clase que almacenan las propiedades y los métodos de la clase. Esto permite utilizar técnicas que pueden parecer extrañas a los programadores de Java y C++, como incluir sentencias o código ejecutable en el nivel superior de una clase o un paquete.

Otra diferencia entre las clases de ActionScript y las clases de Java o C++ es que cada clase de ActionScript tiene algo denominado objetoprototipo. En versiones anteriores de ActionScript, los objetos prototipo, vinculados entre sí en cadenas de prototipos, constituían en conjunto la base de toda la jerarquía de herencia de clases. Sin embargo, en ActionScript 3.0 los objetos prototipo desempeñan una función poco importante en el sistema de herencia. Pero el objeto prototipo puede ser útil como alternativa a las propiedades y los métodos estáticos si se desea compartir una propiedad y su valor entre todas las instancias de una clase.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

En el pasado, los programadores expertos de ActionScript podían manipular directamente la cadena de prototipos con elementos especiales incorporados en el lenguaje. Ahora que el lenguaje proporciona una implementación más madura de una interfaz de programación basada en clases, muchos de estos elementos del lenguaje especiales, como

__proto__ y __resolve, ya no forman parte del lenguaje. Asimismo, las optimizaciones realizadas en el mecanismo

de herencia interno, que aportan mejoras importantes de rendimiento en Flash Player y Adobe AIR, impiden el acceso directo al mecanismo de herencia.

Objetos y clases

En ActionScript 3.0, cada objeto se define mediante una clase. Una clase puede considerarse como una plantilla o un modelo para un tipo de objeto. Las definiciones de clase pueden incluir variables y constantes, que contienen valores de datos y métodos, que son funciones que encapsulan el comportamiento asociado a la clase. Los valores almacenados en propiedades pueden ser valores simples u otros objetos. Los valores simples son números, cadenas o valores booleanos.

ActionScript contiene diversas clases incorporadas que forman parte del núcleo del lenguaje. Algunas de estas clases incorporadas, como Number, Boolean y String, representan los valores simples disponibles en ActionScript. Otras, como las clases Array, Math y XML, definen objetos más complejos.

Todas las clases, tanto las incorporadas como las definidas por el usuario, se derivan de la clase Object. Para los programadores con experiencia previa en ActionScript, es importante tener en cuenta que el tipo de datos Object ya no es el tipo de datos predeterminado, aunque todas las demás clases se deriven de él. En ActionScript 2.0, las dos líneas de código siguientes eran equivalentes, ya que la ausencia de una anotación de tipo significaba que una variable era de tipo Object:

var someObj:Object; var someObj;

En ActionScript 3.0 se introduce el concepto de variables sin tipo, que pueden designarse de las dos maneras siguientes:

var someObj:*; var someObj;

Una variable sin tipo no es lo mismo que una variable de tipo Object. La principal diferencia es que las variables sin tipo pueden contener el valor especial

undefined, mientras que una variable de tipo Object no puede contener ese

valor.

Un programador puede definir sus propias clases mediante la palabra clave definir de tres formas diferentes: las constantes se pueden definir con la palabra clave palabra clave método. Los métodos se declaran con la palabra clave

Para crear una instancia de una clase hay que utilizar el operador la clase Date denominada

var myBirthday:Date = new Date();

var, y las propiedades de captores y definidores con los atributos get y set de una declaración de

function.

new. En el ejemplo siguiente se crea una instancia de

myBirthday.

class. Las propiedades de clase se pueden

const, las variables con la

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Paquetes y espacios de nombres

Los conceptos de paquete y espacio de nombres están relacionados. Los paquetes permiten agrupar definiciones de clase de una manera que permite compartir código fácilmente y minimiza los conflictos de nomenclatura. Los espacios de nombres permiten controlar la visibilidad de los identificadores, como los nombres de propiedades y métodos, y pueden aplicarse a código tanto dentro como fuera de un paquete. Los paquetes permiten organizar los archivos de clase y los espacios de nombres permiten administrar la visibilidad de propiedades y métodos individuales.

Paquetes

En ActionScript 3.0, los paquetes se implementan con espacios de nombres, pero son un concepto distinto. Al declarar un paquete, se crea implícitamente un tipo especial de espacio de nombres que se conoce en tiempo de compilación. Si los espacios de nombres se crean explícitamente, no se conocerán necesariamente en tiempo de compilación.

En el ejemplo siguiente se utiliza la directiva

package samples { public class SampleCode { public var sampleGreeting:String; public function sampleFunction() { trace(sampleGreeting + " from sampleFunction()"); } } }

package para crear un paquete sencillo que contiene una clase:

El nombre de la clase de este ejemplo es SampleCode. Debido a que la clase se encuentra en el interior del paquete samples, el compilador califica el nombre de clase automáticamente en tiempo de compilación como su nombre completo: samples.SampleCode. El compilador también califica los nombres de propiedades y métodos, de forma que

sampleGreeting y sampleFunction() se convierten en samples.SampleCode.sampleGreeting y samples.SampleCode.sampleFunction(), respectivamente.

Muchos desarrolladores, especialmente los que tienen experiencia en programación con Java, pueden elegir colocar únicamente clases en el nivel superior de un paquete. Sin embargo, ActionScript 3.0 no sólo admite clases en el nivel superior de un paquete, sino también variables, funciones e incluso sentencias. Un uso avanzado de esta característica consiste en definir un espacio de nombres en el nivel superior de un paquete de forma que esté disponible para todas las clases del paquete. Sin embargo, hay que tener en cuenta que sólo se admiten dos especificadores de acceso en el nivel superior de un paquete:

public e internal. A diferencia de Java, que permite declarar clases anidadas como

privadas, ActionScript 3.0 no admite clases anidadas privadas ni anidadas.

Sin embargo, en muchos otros aspectos los paquetes de ActionScript 3.0 son similares a los paquetes del lenguaje de programación Java. Como se puede ver en el ejemplo anterior, las referencias de nombre completo a paquetes se expresan con el operador punto (

.), igual que en Java. Se pueden utilizar paquetes para organizar el código en una

estructura jerárquica intuitiva que puedan usar otros programadores. Esto permite compartir código fácilmente, ya que ofrece una manera de crear un paquete para compartirlo con otros y de utilizar en el código paquetes creados por otros.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

El uso de paquetes también ayuda a garantizar que los nombres de los identificadores utilizados son únicos y no entran en conflicto con otros nombres de identificador. De hecho, se podría decir que ésta es la ventaja principal de los paquetes. Por ejemplo, dos programadores que desean compartir código pueden haber creado una clase denominada SampleCode. Sin los paquetes, esto crearía un conflicto de nombres y la única resolución sería cambiar el nombre de una de las clases. Sin embargo, con los paquetes el conflicto de nombres se evita fácilmente colocando una de las clases (o las dos, preferiblemente) en paquetes con nombres únicos.

También se pueden incluir puntos incorporados en el nombre de paquete para crear paquetes anidados. Esto permite crear una organización jerárquica de paquetes. Un buen ejemplo de ello es el paquete flash.xml que proporciona ActionScript 3.0. Este paquete se anida dentro del paquete flash.

El paquete flash.xml contiene el analizador de XML antiguo, que se usaba en versiones anteriores de ActionScript. Una de las razones por las que ahora está en el paquete flash.xml es que hay un conflicto entre el nombre de la clase XML antigua y el nombre de la nueva clase XML que implementa la funcionalidad de la especificación de XML para ECMAScript (E4X) disponible en ActionScript 3.0.

Aunque pasar de la clase XML antigua a un paquete es un buen primer paso, la mayoría de los usuarios de las clases XML antiguas importarán el paquete flash.xml, lo que generará el mismo conflicto de nombres, a menos que recuerden que siempre deben utilizar el nombre completo de la clase XML antigua (flash.xml.XML). Para evitar esta situación, la clase XML antigua ahora se denomina XMLDocument, como se indica en el siguiente ejemplo:

package flash.xml { class XMLDocument {} class XMLNode {} class XMLSocket {} }

La mayor parte de ActionScript 3.0 se organiza en el paquete flash. Por ejemplo, el paquete flash.display contiene la API de la lista de visualización y el paquete flash.events contiene el nuevo modelo de eventos.

Creación de paquetes

ActionScript 3.0 proporciona una gran flexibilidad para organizar los paquetes, las clases y los archivos de código fuente. Las versiones anteriores de ActionScript sólo permitían una clase por archivo de código fuente y requerían que el nombre del archivo coincidiera con el nombre de la clase. ActionScript 3.0 permite incluir varias clases en un archivo de código fuente, pero sólo puede estar disponible una clase de cada archivo para el código externo a ese archivo. Es decir, sólo se puede declarar una clase de cada archivo en una declaración de paquete. Hay que declarar las clases adicionales fuera de la definición de paquete, lo que hace que estas clases sean invisibles para el código externo a ese archivo de código fuente. El nombre de clase declarado en la definición de paquete debe coincidir con el nombre del archivo de código fuente.

ActionScript 3.0 también proporciona más flexibilidad para la declaración de paquetes. En versiones anteriores de ActionScript, los paquetes sólo representaban directorios en los que se colocaban archivos de código fuente y no se declaraban con la sentencia clase en la declaración de clase. Aunque los paquetes siguen representando directorios en ActionScript 3.0, pueden contener algo más que clases. En ActionScript 3.0 se utiliza la sentencia significa que también se pueden declarar variables, funciones y espacios de nombres en el nivel superior de un paquete. Incluso se pueden incluir sentencias ejecutables en el nivel superior de un paquete. Si se declaran variables, funciones o espacios de nombres en el nivel superior de un paquete, los únicos atributos disponibles en ese nivel son

internal, y sólo una declaración de nivel de paquete por archivo puede utilizar el atributo public,

independientemente de que la declaración sea una clase, una variable, una función o un espacio de nombres.

package, sino que se incluía el nombre de paquete como parte del nombre completo de

package para declarar un paquete, lo que

public e

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Los paquetes son útiles para organizar el código y para evitar conflictos de nombres. No se debe confundir el concepto de paquete con el concepto de herencia de clases, que no está relacionado con el anterior. Dos clases que residen en el mismo paquete tendrán un espacio de nombres común, pero no estarán necesariamente relacionadas entre sí de ninguna otra manera. Asimismo, un paquete anidado puede no tener ninguna relación semántica con su paquete principal.

Importación de paquetes

Si se desea utilizar una clase que está dentro un paquete, se debe importar el paquete o la clase específica. Esto varía con respecto a ActionScript 2.0, donde la importación de clases era opcional.

Por ejemplo, considérese el ejemplo de la clase SampleCode mencionado antes en este capítulo. Si la clase reside en un paquete denominado samples, hay que utilizar una de las siguientes sentencias de importación antes de utilizar la clase SampleCode:

import samples.*;

import samples.SampleCode;

En general, la sentencias import deben ser lo más específicas posible. Si se pretende utilizar la clase SampleCode desde el paquete samples, hay que importar únicamente la clase SampleCode, no todo el paquete al que pertenece. La importación de paquetes completos puede producir conflictos de nombres inesperados.

También se debe colocar el código fuente que define el paquete o la clase en la ruta de clases. La ruta de clases es una lista de rutas de directorio locales definida por el usuario que determina dónde buscará el compilador los paquetes y las clases importados. La ruta de clases se denomina a veces ruta de compilación o ruta de código fuente.

Tras importar correctamente la clase o el paquete, se puede utilizar el nombre completo de la clase (samples.SampleCode) o simplemente el nombre de clase (SampleCode).

Los nombres completos son útiles cuando hay ambigüedad en el código a causa de clases, métodos o propiedades con nombre idénticos, pero pueden ser difíciles de administrar si se usan para todos los identificadores. Por ejemplo, la utilización del nombre completo produce código demasiado extenso al crear una instancia de la clase SampleCode:

var mySample:samples.SampleCode = new samples.SampleCode();

A medida que aumentan los niveles de paquetes anidados, la legibilidad del código disminuye. En las situaciones en las que se esté seguro de que los identificadores ambiguos no constituirán un problema, se puede hacer el código más legible utilizando identificadores sencillos. Por ejemplo, al crear una nueva instancia de la clase SampleCode, el resultado será mucho menos extenso si se utiliza sólo el identificador de clase:

var mySample:SampleCode = new SampleCode();

Si se intenta utilizar nombres de identificador sin importar primero el paquete o la clase apropiados, el compilador no podrá encontrar las definiciones de clase. Por otra parte, si se importa un paquete o una clase, cualquier intento de definir un nombre que entre en conflicto con un nombre importado generará un error.

Cuando se crea un paquete, el especificador de acceso predeterminado para todos los miembros del paquete es

internal, lo que significa que, de manera predeterminada, los miembros del paquete sólo estarán visibles para los

otros miembros del paquete. Si se desea que una clase esté disponible para código externo al paquete, se debe declarar la clase como

public. Por ejemplo, el siguiente paquete contiene dos clases, SampleCode y CodeFormatter:

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

// SampleCode.as file package samples { public class SampleCode {} }

// CodeFormatter.as file package samples { class CodeFormatter {} }

El lenguaje ActionScript y su sintaxis

La clase SampleCode está visible fuera del paquete porque se ha declarado como una clase public. Sin embargo, la clase CodeFormatter sólo está visible dentro del mismo paquete samples. Si se intenta acceder la clase CodeFormatter fuera del paquete samples, se generará un error, como se indica en el siguiente ejemplo:

import samples.SampleCode; import samples.CodeFormatter; var mySample:SampleCode = new SampleCode(); // okay, public class var myFormatter:CodeFormatter = new CodeFormatter(); // error

Si se desea que ambas clases estén disponibles para código externo al paquete, se deben declarar las dos como public. No se puede aplicar el atributo

public a la declaración del paquete.

Los nombres completos son útiles para resolver conflictos de nombres que pueden producirse al utilizar paquetes. Este escenario puede surgir si se importan dos paquetes que definen clases con el mismo identificador. Por ejemplo, considérese el siguiente paquete, que también tiene una clase denominada SampleCode:

package langref.samples { public class SampleCode {} }

Si se importan ambas clases de la manera siguiente, se producirá un conflicto de nombres al hacer referencia a la clase SampleCode:

import samples.SampleCode; import langref.samples.SampleCode; var mySample:SampleCode = new SampleCode(); // name conflict

El compilador no sabe qué clase SampleCode debe utilizar. Para resolver este conflicto, hay que utilizar el nombre completo de cada clase, de la manera siguiente:

var sample1:samples.SampleCode = new samples.SampleCode(); var sample2:langref.samples.SampleCode = new langref.samples.SampleCode();

Nota: los programadores con experiencia en C++ suelen confundir la sentencia import con #include. La directiva

#include es necesaria en C++ porque los compiladores de C++ procesan un archivo cada vez y no buscan definiciones

de clases en otros archivos, a menos que se incluya explícitamente un archivo de encabezado. ActionScript 3.0 tiene una directiva ActionScript 3.0, hay que usar la sentencia

include, pero no está diseñada para importar clases y paquetes. Para importar clases o paquetes en

import y colocar el archivo de código fuente que contiene el paquete en la ruta

de clases.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Espacios de nombres

Los espacios de nombres ofrecen control sobre la visibilidad de las propiedades y los métodos que se creen. Los especificadores de control de acceso Si estos especificadores de control de acceso predefinidos no se adaptan a las necesidades del programador, es posible crear espacios de nombres personalizados.

Para los programadores que estén familiarizados con los espacios de nombres XML, gran parte de lo que se va a explicar no resultará nuevo, aunque la sintaxis y los detalles de la implementación de ActionScript son ligeramente distintos de los de XML. Si nunca se ha trabajado con espacios de nombres, el concepto en sí es sencillo, pero hay que aprender la terminología específica de la implementación.

Para comprender mejor cómo funcionan los espacios de nombres, es necesario saber que el nombre de una propiedad o un método siempre contiene dos partes: un identificador y un espacio de nombres. El identificador es lo que generalmente se considera un nombre. Por ejemplo, los identificadores de la siguiente definición de clase son

sampleGreeting y sampleFunction():

class SampleCode { var sampleGreeting:String; function sampleFunction () { trace(sampleGreeting + " from sampleFunction()"); } }

public, private, protected e internal son espacios de nombres incorporados.

Siempre que las definiciones no estén precedidas por un atributo de espacio de nombres, sus nombres se califican mediante el espacio de nombres

internal predeterminado, lo que significa que sólo estarán visibles para los orígenes

de llamada del mismo paquete. Si el compilador está configurado en modo estricto, emite una advertencia para indicar que el espacio de nombres

internal se aplica a cualquier identificador que no tenga un atributo de espacio de

nombres. Para asegurarse de que un identificador esté disponible en todas partes, hay que usar específicamente el atributo

sampleFunction() tienen internal como valor de espacio de nombres.

public como prefijo del nombre de identificador. En el ejemplo de código anterior, sampleGreeting y

Se deben seguir tres pasos básicos al utilizar espacios de nombres. En primer lugar, hay que definir el espacio de nombres con la palabra clave

namespace version1;

namespace. Por ejemplo, el código siguiente define el espacio de nombres version1:

En segundo lugar, se aplica el espacio de nombres utilizándolo en lugar de utilizar un especificador de control de acceso en una declaración de propiedad o método. El ejemplo siguiente coloca una función denominada el espacio de nombres

version1 function myFunction() {}

version1:

myFunction() en

En tercer lugar, tras aplicar el espacio de nombres, se puede hacer referencia al mismo con la directiva use o calificando el nombre de un identificador con un espacio de nombres. En el ejemplo siguiente se hace referencia a la función

myFunction() mediante la directiva use:

use namespace version1; myFunction();

También se puede utilizar un nombre completo para hacer referencia a la función myFunction(), como se indica en el siguiente ejemplo:

version1::myFunction();

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Definición de espacios de nombres

Los espacios de nombres contienen un valor, el Identificador uniforme de recurso (URI), que a veces se denomina nombre del espacio de nombres. El URI permite asegurarse de que la definición del espacio de nombres es única.

Para crear un espacio de nombres se declara una definición de espacio de nombres de una de las dos maneras siguientes. Se puede definir un espacio de nombres con un URI explícito, de la misma manera que se define un espacio de nombres XML, o se puede omitir el URI. En el siguiente ejemplo se muestra la manera de definir un espacio de nombres mediante un URI:

namespace flash_proxy = "http://www.adobe.com/flash/proxy";

El URI constituye una cadena de identificación única para ese espacio de nombres. Si se omite el URI, como en el siguiente ejemplo, el compilador creará una cadena de identificación interna única en lugar del URI. El usuario no tiene acceso a esta cadena de identificación interna.

namespace flash_proxy;

Una vez definido un espacio de nombres, con o sin URI, ese espacio de nombres no podrá definirse de nuevo en el mismo ámbito. Si se intenta definir un espacio de nombres definido previamente en el mismo ámbito, se producirá un error del compilador.

Si se define un espacio de nombres dentro de un paquete o una clase, el espacio de nombres puede no estar visible para código externo al paquete o la clase, a menos que se use el especificador de control de acceso apropiado. Por ejemplo, el código siguiente muestra el espacio de nombres ejemplo, la falta de un especificador de control de acceso significa que el espacio de nombres

flash_proxy definido en el paquete flash.utils. En el siguiente

flash_proxy sólo estará

visible para el código del paquete flash.utils y no estará visible para el código externo al paquete:

package flash.utils { namespace flash_proxy; }

El código siguiente utiliza el atributo public para hacer que el espacio de nombres flash_proxy esté visible para el código externo al paquete:

package flash.utils { public namespace flash_proxy; }

Aplicación de espacios de nombres

Aplicar un espacio de nombres significa colocar una definición en un espacio de nombres. Entre las definiciones que se puede colocar en espacios de nombres se incluyen funciones, variables y constantes (no se puede colocar una clase en un espacio de nombres personalizado).

Considérese, por ejemplo, una función declarada con el espacio de nombres de control de acceso el atributo

public en una definición de función se coloca la función en el espacio de nombres public, lo que hace que

public. Al utilizar

esté disponible para todo el código. Una vez definido un espacio de nombres, se puede utilizar el espacio de nombres definido de la misma manera que se utilizaría el atributo

public y la definición estará disponible para el código que

puede hacer referencia al espacio de nombres personalizado. Por ejemplo, si se define un espacio de nombres

example1, se puede añadir un método denominado myFunction() utilizando example1 como un atributo, como se

indica en el siguiente ejemplo:

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

namespace example1; class someClass { example1 myFunction() {} }

El lenguaje ActionScript y su sintaxis

Si se declara el método myFunction() con el espacio de nombres example1 como un atributo, significa que el método pertenece al espacio de nombres

example1.

Se debe tener en cuenta lo siguiente al aplicar espacios de nombres:

• Sólo se puede aplicar un espacio de nombres a cada declaración.

• No hay manera de aplicar un atributo de espacio de nombres a más de una definición simultáneamente. Es decir,

si se desea aplicar el espacio de nombres a diez funciones distintas, se debe añadir el espacio de nombres como un atributo a cada una de las diez definiciones de función.

• Si se aplica un espacio de nombres, no se puede especificar también un especificador de control de acceso, ya que

los espacios de nombres y los especificadores de control de acceso son mutuamente excluyentes. Es decir, no se puede declarar una función o propiedad como

public, private, protected o internal y aplicar también el

espacio de nombres.

Referencia a un espacio de nombres

No es necesario hacer referencia explícita a un espacio de nombres al usar un método o una propiedad declarados con alguno de los espacios de nombres de control de acceso, como

public, private, protected e internal. Esto se debe

a que el acceso a estos espacios de nombres especiales se controla por el contexto. Por ejemplo, las definiciones colocadas en el espacio de nombres

private estarán disponibles automáticamente para el código de la misma clase.

Sin embargo, para los espacios de nombres personalizados que se definan no existirá este control mediante el contexto. Para poder utilizar un método o una propiedad que se ha colocado en un espacio de nombres personalizado, se debe hacer referencia al espacio de nombres.

Se puede hacer referencia a espacios de nombres con la directiva el espacio de nombres mediante el signo calificador de nombre ( la directiva

use namespace "se abre" el espacio de nombres, de forma que se puede aplicar a cualquier identificador

que no esté calificado. Por ejemplo, si se define el espacio de nombres espacio de nombres mediante

use namespace example1; myFunction();

use namespace example1:

use namespace o se puede calificar el nombre con

::). Al hacer referencia a un espacio de nombres con

example1, se puede acceder a nombres de ese

Es posible abrir más de un espacio de nombres simultáneamente. Cuando se abre un espacio de nombres con use

namespace, permanece abierto para todo el bloque de código en el que se abrió. No hay forma de cerrar un espacio de

nombres explícitamente.

Sin embargo, si hay más de un espacio de nombres abierto, aumenta la probabilidad de que se produzcan conflictos de nombres. Si se prefiere no abrir un espacio de nombres, se puede evitar la directiva

use namespace calificando el

nombre del método o la propiedad con el espacio de nombres y el signo calificador de nombre. Por ejemplo, el código siguiente muestra la manera de calificar el nombre

example1::myFunction();

myFunction() con el espacio de nombres example1:

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Utilización de espacios de nombres

Puede encontrar un ejemplo real de un espacio de nombres que se utiliza para evitar conflictos de nombre en la clase flash.utils.Proxy que forma parte de ActionScript 3.0. La clase Proxy, que es la sustitución de la propiedad

Object.__resolve de ActionScript 2.0, permite interceptar referencias a propiedades o métodos no definidos antes

de que se produzca un error. Todos los métodos de la clase Proxy residen en el espacio de nombres

flash_proxy para

evitar conflictos de nombres.

Para entender mejor cómo se utiliza el espacio de nombres

flash_proxy, hay que entender cómo se utiliza la clase

Proxy. La funcionalidad de la clase Proxy sólo está disponible para las clases que heredan de ella. Es decir, si se desea utilizar los métodos de la clase Proxy en un objeto, la definición de clase del objeto debe ampliar la clase Proxy. Por ejemplo, si desea se interceptar intentos de llamar a un método no definido, se debe ampliar la clase Proxy y después reemplazar el método

callProperty() de la clase Proxy.

La implementación de espacios de nombres es generalmente un proceso en tres pasos consistente en definir y aplicar un espacio de nombres, y después hacer referencia al mismo. Sin embargo, como nunca se llama explícitamente a ninguno de los métodos de la clase Proxy, sólo se define y aplica el espacio de nombres hace referencia al mismo. ActionScript 3.0 define el espacio de nombres código sólo tiene que aplicar el espacio de nombres

El espacio de nombres

package flash.utils { public namespace flash_proxy; }

flash_proxy se define en el paquete flash.utils de una manera similar a la siguiente:

flash_proxy a las clases que amplían la clase Proxy.

flash_proxy y lo aplica en la clase Proxy. El

flash_proxy, pero nunca se

El espacio de nombres se aplica a los métodos de la clase Proxy, como se indica en el siguiente fragmento de dicha clase:

public class Proxy { flash_proxy function callProperty(name:*, ... rest):* flash_proxy function deleteProperty(name:*):Boolean ... }

Como se indica en el código siguiente, se debe importar primero la clase Proxy y el espacio de nombres flash_proxy. A continuación se debe declarar la clase de forma que amplíe la clase Proxy (también se debe añadir el atributo

dynamic si se compila en modo estricto). Al sustituir el método callProperty(), se debe utilizar el espacio de

nombres

package { import flash.utils.Proxy; import flash.utils.flash_proxy;

dynamic class MyProxy extends Proxy { flash_proxy override function callProperty(name:*, ...rest):* { trace("method call intercepted: " + name); } } }

flash_proxy.

Si se crea una instancia de la clase MyProxy y se llama a un método no definido, como el método testing() llamado en el ejemplo siguiente, el objeto Proxy intercepta la llamada al método y ejecuta las sentencias del método

callProperty() sustituido (en este caso, una simple sentencia trace()).

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

var mySample:MyProxy = new MyProxy(); mySample.testing(); // method call intercepted: testing

El lenguaje ActionScript y su sintaxis

Tener los métodos de la clase Proxy dentro del espacio de nombres flash_proxy ofrece dos ventajas. En primer lugar, tener un espacio de nombres independiente reduce el desorden en la interfaz pública de cualquier clase que amplíe la clase Proxy. (Hay aproximadamente una docena de métodos en la clase Proxy que se pueden sustituir; todos ellos han sido diseñados para no ser llamados directamente. Colocarlos todos en el espacio de nombres public podría provocar confusiones.) En segundo lugar, el uso del espacio de nombres

flash_proxy evita los conflictos de nombres en caso

de que la subclase de Proxy contenga métodos de instancia con nombres que coincidan con los de los métodos de la clase Proxy. Por ejemplo, supongamos que un programador desea asignar a uno de sus métodos el nombre

callProperty(). El código siguiente es aceptable porque su versión del método callProperty() está en un espacio

de nombres distinto:

dynamic class MyProxy extends Proxy { public function callProperty() {} flash_proxy override function callProperty(name:*, ...rest):* { trace("method call intercepted: " + name); } }

Los espacios de nombres también pueden ser útiles cuando se desea proporcionar acceso a métodos o propiedades de una manera que se no puede realizar con los cuatro especificadores de control de acceso (

protected). Por ejemplo, un programador puede tener algunos métodos de utilidad repartidos por varios paquetes.

public, private, internal

Desea que estos métodos estén disponibles para todos los paquetes, pero no quiere que sean públicos. Para ello, se puede crear un nuevo espacio de nombres y utilizarlo como un especificador de control de acceso especial.

En el ejemplo siguiente se utiliza un espacio de nombres definido por el usuario para agrupar dos funciones que residen en paquetes distintos. Al agruparlos en el mismo espacio de nombres, se puede hacer que ambas funciones estén visibles para una clase o un paquete mediante una única sentencia

use namespace.

En este ejemplo se utilizan cuatro archivos para ilustrar la técnica. Todos los archivos deben estar en la ruta de clases. El primer archivo, myInternal.as, se utiliza para definir el espacio de nombres

myInternal. Como el archivo está en

un paquete denominado example, se debe colocar en una carpeta denominada example. El espacio de nombres se marca como

// myInternal.as in folder example package example { public namespace myInternal = "http://www.adobe.com/2006/actionscript/examples"; }

public de forma que se pueda importar en otros paquetes.

Los archivos Utility.as y Helper.as definen las clases que contienen los métodos que deben estar disponibles para otros paquetes. La clase Utility está en el paquete example.alpha, lo que significa que se debe colocar el archivo dentro de una subcarpeta de la carpeta example denominada alpha. La clase Helper está en el paquete example.beta, por lo que se debe colocar el archivo dentro de otra subcarpeta de la carpeta example denominada beta. Ambos paquetes, example.alpha y example.beta, deben importar el espacio de nombres antes de utilizarlo.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

// Utility.as in the example/alpha folder package example.alpha { import example.myInternal;

public class Utility { private static var _taskCounter:int = 0;

public static function someTask() { _taskCounter++; }

myInternal static function get taskCounter():int { return _taskCounter; } } }

// Helper.as in the example/beta folder package example.beta { import example.myInternal;

public class Helper { private static var _timeStamp:Date;

public static function someTask() { _timeStamp = new Date(); }

myInternal static function get lastCalled():Date { return _timeStamp; } } }

El lenguaje ActionScript y su sintaxis

El cuarto archivo, NamespaceUseCase.as, es la clase principal de la aplicación, y debe estar en el mismo nivel que la carpeta example. En Adobe Flash CS4 Professional, esta clase se utilizaría como la clase de documento para el archivo FLA. La clase NamespaceUseCase también importa el espacio de nombres

myInternal y lo utiliza para llamar a los

dos métodos estáticos que residen en los otros paquetes. El ejemplo utiliza métodos estáticos sólo para simplificar el código. Se pueden colocar tanto métodos estáticos como métodos de instancia en el espacio de nombres

myInternal.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

// NamespaceUseCase.as package { import flash.display.MovieClip; import example.myInternal; // import namespace import example.alpha.Utility;// import Utility class import example.beta.Helper;// import Helper class

public class NamespaceUseCase extends MovieClip { public function NamespaceUseCase() { use namespace myInternal;

Utility.someTask(); Utility.someTask(); trace(Utility.taskCounter); // 2

Helper.someTask(); trace(Helper.lastCalled); // [time someTask() was last called] } } }

Variables

Las variables permiten almacenar los valores que se utilizan en el programa. Para declarar una variable se debe utilizar la sentencia anotaciones de tipo de datos. En ActionScript 3.0, el uso de la sentencia línea siguiente de código ActionScript declara una variable denominada

var i;

Si se omite la sentencia var al declarar una variable, se producirá un error del compilador en modo estricto y un error en tiempo de ejecución en modo estándar. Por ejemplo, la siguiente línea de código producirá un error si la variable no se ha definido previamente:

i; // error if i was not previously defined

La asociación de una variable con un tipo de datos, debe realizarse al declarar la variable. Es posible declarar una variable sin designar su tipo, pero esto generará una advertencia del compilador en modo estricto. Para designar el tipo de una variable se añade el nombre de la variable con un signo de dos puntos (:), seguido del tipo de la variable. Por ejemplo, el código siguiente declara una variable

var i:int;

Se puede asignar un valor a una variable mediante el operador de asignación (=). Por ejemplo, el código siguiente declara una variable

var i:int; i = 20;

Puede ser más cómodo asignar un valor a una variable a la vez que se declara la variable, como en el siguiente ejemplo:

var con el nombre de variable. En ActionScript 2.0, el uso de la sentencia var sólo es necesario si se usan

var es siempre obligatorio. Por ejemplo, la

i de tipo int:

i y le asigna el valor 20:

var i:int = 20;

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

La técnica de asignar un valor a una variable en el momento de declararla se suele utilizar no sólo al asignar valores simples, como enteros y cadenas, sino también al crear un conjunto o una instancia de una clase. En el siguiente ejemplo se muestra un conjunto que se declara y recibe un valor en una línea de código.

var numArray:Array = ["zero", "one", "two"];

Para crear una instancia de una clase hay que utilizar el operador new. En el ejemplo siguiente se crea una instancia de una clase denominada denominada

var customItem:CustomClass = new CustomClass();

customItem:

CustomClass y se asigna una referencia a la instancia de clase recién creada a la variable

Si hubiera que declarar más de una variable, se pueden declarar todas en una línea de código utilizando el operador

,) para separar las variables. Por ejemplo, el código siguiente declara tres variables en una línea de código:

coma (

var a:int, b:int, c:int;

También se puede asignar valores a cada una de las variables en la misma línea de código. Por ejemplo, el código siguiente declara tres variables (

var a:int = 10, b:int = 20, c:int = 30;

a, b y c) y asigna un valor a cada una de ellas:

Aunque se puede utilizar el operador coma para agrupar declaraciones de variables en una sentencia, al hacerlo el código será menos legible.

Aspectos básicos del ámbito de variables

El ámbito de una variable es el área del código en la que se puede acceder a la variable mediante una referencia léxica. Una variable global está definida en todas las áreas del código, mientras que una variable local sólo está definida en una parte del código. En ActionScript 3.0, las variables siempre se asignan al ámbito de la función o la clase en la que se han declarado. Una variable global es una variable que se define fuera de una definición de función o clase. Por ejemplo, el código siguiente crea una variable global variable global está disponible tanto dentro como fuera de una definición de función.

var strGlobal:String = "Global"; function scopeTest() { trace(strGlobal); // Global } scopeTest(); trace(strGlobal); // Global

Las variables locales se declaran dentro de una definición de función. La parte más pequeña de código para la que se puede definir una variable local es una definición de función. Una variable local declarada en una función sólo existirá en esa función. Por ejemplo, si se declara una variable denominada

localScope(), dicha variable no estará disponible fuera de la función.

function localScope() { var strLocal:String = "local"; } localScope(); trace(strLocal); // error because strLocal is not defined globally

strGlobal declarándola fuera de las funciones. El ejemplo muestra que una

str2 dentro de una función denominada

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Si el nombre de la variable que utiliza para la variable local ya se ha declarado como variable global, la definición local oculta (o reemplaza) la definición global mientras la variable local se encuentre dentro del ámbito. La variable global continuará existiendo fuera de la función. Por ejemplo, el siguiente fragmento de código crea una variable de cadena global denominada

scopeTest(). La sentencia trace de la función devuelve el valor local de la variable, pero la sentencia trace situada

str1 y a continuación crea una variable local con el mismo nombre dentro de la función

fuera de la función devuelve el valor global de la variable.

var str1:String = "Global"; function scopeTest () { var str1:String = "Local"; trace(str1); // Local } scopeTest(); trace(str1); // Global

Las variables de ActionScript, a diferencia de las variables de C++ y Java, no tienen ámbito a nivel de bloque. Un bloque de código es un grupo de sentencias entre una llave inicial (

{ ) y una llave final ( } ). En algunos lenguajes de

programación, como C++ y Java, las variables declaradas dentro de un bloque de código no están disponibles fuera de ese bloque de código. Esta restricción de ámbito se denomina ámbito a nivel de bloque y no existe en ActionScript. Si se declara una variable dentro de un bloque de código, dicha variable no sólo estará disponible en ese bloque de código, sino también en cualquier otra parte de la función a la que pertenece el bloque de código. Por ejemplo, la siguiente función contiene variables definidas en varios ámbitos de bloque. Todas las variables están disponibles en toda la función.

blockTest(["Earth", "Moon", "Sun"]);

Una consecuencia interesante de la falta de ámbito a nivel de bloque es que se puede leer el valor de una variable o escribir en ella antes de que se declare, con tal de que se declare antes del final de la función. Esto se debe a una técnica denominada hoisting, que consiste en que el compilador mueve todas las declaraciones de variables al principio de la función. Por ejemplo, el código siguiente se compila aunque la función de la declaración de la variable

trace(num); // NaN var num:Number = 10; trace(num); // 10

num:

trace() inicial para la variable num está antes

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Sin embargo, el compilador no mueve ninguna sentencia de asignación al principio. Esto explica por qué la función

trace() inicial de num devuelve NaN (no es un número), que es el valor predeterminado para variables con tipo de

datos Number. Así, es posible asignar valores a variables incluso antes de declararlas, como se muestra en el siguiente ejemplo:

num = 5; trace(num); // 5 var num:Number = 10; trace(num); // 10

Valores predeterminados

Un valor predeterminado es el valor que contiene una variable antes de que se establezca su valor. Una variable se inicializa al establecer su valor por primera vez. Si se declara una variable pero no establece su valor, dicha variable

estará sin inicializar. El valor de una variable no inicializada depende del tipo de datos que tenga. En la tabla siguiente se describen los valores predeterminados de las variables, clasificados por tipo de datos:

Tipo de datos Valor predeterminado

Boolean

int 0

Number

Object null

String null

uint 0

No declarada (equivalente a anotación de tipo

Todas las demás clases, incluidas las clases definidas por el usuario. null

*) undefined

Para variables de tipo Number, el valor predeterminado es

false

NaN

NaN (no es un número), que es un valor especial definido

por la norma IEEE-754 para designar un valor que no representa un número.

Si se declara una variable pero no se declara su tipo de datos, se aplica el tipo de datos predeterminado,

*, que en

realidad indica que la variable no tiene tipo. Si tampoco se inicializa una variable sin tipo con un valor, su valor predeterminado será

undefined.

Para tipos de datos distintos de Boolean, Number, int y uint, el valor predeterminado de cualquier variable no inicializada es

null. Esto se aplica a todas las clases definidas mediante ActionScript 3.0, así como a las clases

personalizadas que se creen.

El valor

null no es válido para variables de tipo Boolean, Number, int o uint. Si se intenta asignar el valor null a una

variable de este tipo, dicho valor se convierte en el valor predeterminado para ese tipo de datos. A las variables de tipo Object se les puede asignar un valor valor se convierte en

null.

null. Si se intenta asignar el valor undefined a una variable de tipo Object, dicho

Para variables de tipo Number, hay una función especial de nivel superior denominada booleano

true si la variable no es un número, y false en caso contrario.

isNaN() que devuelve el valor

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Tipos de datos

Un tipo de datos define un conjunto de valores. Por ejemplo, el tipo de datos Boolean es el conjunto de dos valores bien definidos: con frecuencia, como String, Number y Array. Un programador puede definir sus propios tipos de datos utilizando clases o interfaces para definir un conjunto de valores personalizado. En ActionScript 3.0 todos los valores, tanto simples como complejos, son objetos.

Un valor simple es un valor que pertenece a uno de los tipos de datos siguientes: Boolean, int, Number, String y uint. Trabajar con valores simples suele ser más rápido que trabajar con valores complejos, ya que ActionScript almacena los valores simples de una manera especial que permite optimizar la velocidad y el uso de la memoria.

Nota: para los interesados en los detalles técnicos, ActionScript almacena internamente los valores simples como objetos inmutables. El hecho de que se almacenen como objetos inmutables significa que pasar por referencia es en realidad lo mismo que pasar por valor. Esto reduce el uso de memoria y aumenta la velocidad de ejecución, ya que las referencias ocupan normalmente bastante menos que los valores en sí.

Un valor complejo es un valor que no es un valor simple. Entre los tipos de datos que definen conjuntos de valores complejos se encuentran Array, Date, Error, Function, RegExp, XML y XMLList.

Muchos lenguajes de programación distinguen entre los valores simples y los objetos que los contienen. Java, por ejemplo, tiene un valor simple int y la clase java.lang.Integer que lo contiene. Los valores simples de Java no son objetos, pero los objetos que los contienen sí, lo que hace que los valores simples sean útiles para algunas operaciones y los objetos contenedores sean más adecuados para otras operaciones. En ActionScript 3.0, los valores simples y sus objetos contenedores son, para fines prácticos, indistinguibles. Todos los valores, incluso los valores simples, son objetos. Flash Player y Adobe AIR tratan estos tipos simples como casos especiales que se comportan como objetos pero que no requieren la sobrecarga normal asociada a la creación de objetos. Esto significa que las dos líneas de código siguientes son equivalentes:

true y false. Además del tipo de datos Boolean, ActionScript 3.0 define varios tipos de datos utilizados

var someInt:int = 3; var someInt:int = new int(3);

Todos los tipos de datos simples y complejos antes descritos se definen en las clases principales de ActionScript 3.0. Las clases principales permiten crear objetos utilizando valores literales en lugar de utilizar el operador

new. Por

ejemplo, se puede crear un conjunto utilizando un valor literal o el constructor de la clase Array, de la manera siguiente:

var someArray:Array = [1, 2, 3]; // literal value var someArray:Array = new Array(1,2,3); // Array constructor

Verificación de tipos

La verificación de tipos puede tener lugar al compilar o en tiempo de ejecución. Los lenguajes con tipos estáticos, como C++ y Java, realizan la verificación de tipos en tiempo de compilación. Los lenguajes con tipos dinámicos, como Smalltalk y Python, realizan la verificación de tipos en tiempo de ejecución. Al ser un lenguaje con tipos dinámicos, ActionScript 3.0 ofrece verificación de tipos en tiempo de ejecución, pero también admite verificación de tipos en tiempo de compilación con un modo de compilador especial denominado modo estricto. En modo estricto, la verificación de tipos se realiza en tiempo de compilación y en tiempo de ejecución; en cambio, en modo estándar la verificación de tipos sólo se realiza en tiempo de ejecución.

Los lenguajes con tipos dinámicos ofrecen una gran flexibilidad para estructurar el código, pero a costa de permitir que se produzcan errores de tipo en tiempo de ejecución. Los lenguajes con tipos estáticos notifican los errores de tipo en tiempo de compilación, pero a cambio deben conocer la información de tipos en tiempo de compilación.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Verificación de tipos en tiempo de compilación

La verificación de tipos en tiempo de compilación se suele favorecer en los proyectos grandes ya que, a medida que el tamaño de un proyecto crece, la flexibilidad de los tipos de datos suele ser menos importante que detectar los errores de tipo lo antes posible. Ésta es la razón por la que, de manera predeterminada, el compilador de ActionScript de Adobe Flash CS4 Professional y Adobe Flex Builder está configurado para ejecutarse en modo estricto.

Para poder proporcionar verificación de tipos en tiempo de compilación, el compilador necesita saber cuáles son los tipos de datos de las variables o las expresiones del código. Para declarar explícitamente un tipo de datos para una variable, se debe añadir el operador dos puntos (

:) seguido del tipo de datos como sufijo del nombre de la variable.

Para asociar un tipo de datos a un parámetro, se debe utilizar el operador dos puntos seguido del tipo de datos. Por ejemplo, el código siguiente añade la información de tipo de datos al parámetro

xParam y declara una variable myParam

con un tipo de datos explícito:

function runtimeTest(xParam:String) { trace(xParam); } var myParam:String = "hello"; runtimeTest(myParam);

En modo estricto, el compilador de ActionScript notifica los tipos no coincidentes como errores de compilación. Por ejemplo, el código siguiente declara un parámetro de función

xParam, de tipo Object, pero después intenta asignar

valores de tipo String y Number a ese parámetro. Esto produce un error del compilador en modo estricto.

Sin embargo, incluso en modo estricto se puede evitar selectivamente la verificación de tipos en tiempo de compilación dejando sin tipo el lado derecho de una sentencia de asignación. También se puede marcar una variable o expresión como variable o expresión sin tipo, omitiendo una anotación de tipo o utilizando la anotación de tipo asterisco ( Por ejemplo, si se modifica el parámetro

xParam del ejemplo anterior de forma que ya no tenga una anotación de tipo,

*).

el código se compilará en modo estricto:

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Verificación de tipos en tiempo de ejecución

ActionScript 3.0 realiza la verificación de tipos en tiempo de ejecución tanto si se compila en modo estricto como si se compila en modo estándar. Considérese una situación en la que se pasa el valor 3 como argumento a una función que espera un conjunto. En modo estricto, el compilador generará un error, ya que el valor 3 no es compatible con el tipo de datos Array. Al desactivar el modo estricto y entrar en modo estándar, el compilador no notificará acerca de los tipos no coincidentes, pero la verificación de tipos en tiempo de ejecución realizada por Flash Player y Adobe AIR dará lugar a un error en tiempo de ejecución.

En el siguiente ejemplo se muestra una función denominada

typeTest() que espera un argumento de tipo Array pero

recibe el valor 3. Esto provoca un error en tiempo de ejecución en modo estándar, ya que el valor 3 no es un miembro del tipo de datos (Array) declarado para el parámetro.

function typeTest(xParam:Array) { trace(xParam); } var myNum:Number = 3; typeTest(myNum); // run-time error in ActionScript 3.0 standard mode

También puede haber situaciones en las que se produzca un error de tipo en tiempo de ejecución aunque se opere en modo estricto. Esto puede suceder si se usa el modo estricto pero se elige no verificar tipos en tiempo de compilación utilizando una variable sin tipo. Si se utiliza una variable sin tipo, no se elimina la verificación de tipos, sino que se aplaza hasta el tiempo de ejecución. Por ejemplo, si la variable

myNum del ejemplo anterior no tiene un tipo de datos

declarado, el compilador no podrá detectar los tipos no coincidentes, pero Flash Player y Adobe AIR generarán un error en tiempo de ejecución al comparar el valor en tiempo de ejecución de resultado de la sentencia de asignación, con el tipo de

function typeTest(xParam:Array) { trace(xParam); } var myNum = 3; typeTest(myNum); // run-time error in ActionScript 3.0

xParam, que está definido como el tipo de datos Array.

myNum, que está definido en 3 como

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

La verificación de tipos en tiempo de ejecución también permite un uso más flexible de la herencia que la verificación en tiempo de compilación. Al aplazar la verificación de tipos al tiempo de ejecución, el modo estándar permite hacer referencia a propiedades de una subclase aunque se realice una conversión hacia arriba. Una conversión hacia arriba se produce si se utiliza una clase base para declarar el tipo de una instancia de la clase y una subclase para crear la instancia. Por ejemplo, se puede crear una clase denominada ClassBase ampliable (las clases con el atributo

final no

se pueden ampliar):

class ClassBase { }

Posteriormente se puede crear una subclase de ClassBase denominada ClassExtender, con una propiedad denominada

someString, como se indica a continuación:

class ClassExtender extends ClassBase { var someString:String; }

Se pueden usar ambas clases para crear una instancia de clase que se declara con el tipo de datos de ClassBase, pero se crea con el constructor de ClassExtender. Una conversión hacia arriba se considera una operación segura porque la clase base no contiene ninguna propiedad o método que no esté en la subclase.

var myClass:ClassBase = new ClassExtender();

No obstante, una subclase contiene propiedades o métodos que la clase base no contiene. Por ejemplo, la clase ClassExtender contiene la propiedad ActionScript 3.0 se puede hacer referencia a esta propiedad mediante la instancia de

someString, que no existe en la clase ClassBase. En el modo estándar de

myClass sin generar un error de

tiempo de compilación, como se muestra en el siguiente ejemplo:

var myClass:ClassBase = new ClassExtender(); myClass.someString = "hello"; // no error in ActionScript 3.0 standard mode

Operador is

El operador miembro de un tipo de datos determinado. En versiones anteriores de ActionScript el operador proporcionaba esta funcionalidad, pero en ActionScript 3.0 no se debe utilizar el operador comprobar la pertenencia a un tipo de datos. Para la verificación manual de tipos se debe utilizar el operador lugar del operador prototipos de

is, una de las novedades de ActionScript 3.0, permite comprobar si una variable o expresión es un

instanceof

instanceof para

is en

instanceof, ya que la expresión x instanceof y simplemente comprueba en la cadena de

x si existe y (y en ActionScript 3.0, la cadena de prototipos no proporciona una imagen completa de la

jerarquía de herencia).

El operador

is examina la jerarquía de herencia adecuada y se puede utilizar no sólo para verificar si un objeto es una

instancia de una clase específica, sino también en el caso de que un objeto sea una instancia de una clase que implementa una interfaz determinada. En el siguiente ejemplo se crea una instancia de la clase Sprite denominada

mySprite y se utiliza el operador is para comprobar si mySprite es una instancia de las clases Sprite y DisplayObject,

y si implementa la interfaz IEventDispatcher.

var mySprite:Sprite = new Sprite(); trace(mySprite is Sprite); // true trace(mySprite is DisplayObject);// true trace(mySprite is IEventDispatcher); // true

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

El operador is comprueba la jerarquía de herencia y notifica que mySprite es compatible con las clases Sprite y DisplayObject (la clase Sprite es una subclase de la clase DisplayObject). El operador

mySprite hereda de alguna clase que implementa la interfaz IEventDispatcher. Como la clase Sprite hereda de la clase

EventDispatcher, que implementa la interfaz IEventDispatcher, el operador

is notifica correctamente que mySprite

is también comprueba si

implementa la misma interfaz.

En el siguiente ejemplo se muestran las mismas pruebas del ejemplo anterior, pero con operador DisplayObject, pero devuelve

is. El operador instanceof identifica correctamente que mySprite es una instancia de Sprite o

false cuando se usa para comprobar si mySprite implementa la interfaz

instanceof en lugar del

IEventDispatcher.

trace(mySprite instanceof Sprite); // true trace(mySprite instanceof DisplayObject);// true trace(mySprite instanceof IEventDispatcher); // false

Operador as

El operador de un tipo de datos determinado. Sin embargo, a diferencia del operador booleano. El operador ejemplo se muestran los resultados de utilizar el operador

as, una de las novedades de ActionScript 3.0, también permite comprobar si una expresión es un miembro

is, el operador as no devuelve un valor

as devuelve el valor de la expresión en lugar de true y null en lugar de false. En el siguiente

as en lugar del operador is en el caso sencillo de comprobar

si una instancia de Sprite es un miembro de los tipos de datos DisplayObject, IEventDispatcher y Number.

var mySprite:Sprite = new Sprite(); trace(mySprite as Sprite); // [object Sprite] trace(mySprite as DisplayObject); // [object Sprite] trace(mySprite as IEventDispatcher); // [object Sprite] trace(mySprite as Number); // null

Al utilizar el operador as, el operando de la derecha debe ser un tipo de datos. Si se intenta utilizar una expresión que no sea un tipo de datos como operando de la derecha se producirá un error.

Clases dinámicas

Una clase dinámica define un objeto que se puede modificar en tiempo de ejecución añadiendo o modificando propiedades y métodos. Una clase que no es dinámica, como la clase String, es una clase cerrada. No es posible añadir propiedades o métodos a una clase cerrada en tiempo de ejecución.

Para crear clases dinámicas se utiliza el atributo una clase dinámica denominada

dynamic class Protean { private var privateGreeting:String = "hi"; public var publicGreeting:String = "hello"; function Protean() { trace("Protean instance created"); } }

Protean:

Si posteriormente se crea una instancia de la clase Protean, se pueden añadir propiedades o métodos fuera de la definición de clase. Por ejemplo, el código siguiente crea una instancia de la clase denominada

aString y otra propiedad denominada aNumber a la instancia:

dynamic al declarar una clase. Por ejemplo, el código siguiente crea

Protean y añade una propiedad

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

var myProtean:Protean = new Protean(); myProtean.aString = "testing"; myProtean.aNumber = 3; trace(myProtean.aString, myProtean.aNumber); // testing 3

Las propiedades que se añaden a una instancia de una clase dinámica son entidades de tiempo de ejecución, por lo que no se realiza ninguna verificación de tipos en tiempo de ejecución. No se puede añadir una anotación de tipo a una propiedad añadida de esta manera.

También se puede añadir un método a la instancia de propiedad de la instancia de

traceProtean():

var myProtean:Protean = new Protean(); myProtean.aString = "testing"; myProtean.aNumber = 3; myProtean.traceProtean = function () { trace(this.aString, this.aNumber); }; myProtean.traceProtean(); // testing 3

myProtean. El código siguiente mueve la sentencia trace a un método denominado

myProtean definiendo una función y asociando la función a una

Sin embargo, los métodos creados de esta manera no tienen acceso a ninguna propiedad o método privado de la clase Protean. Además, incluso las referencias a las propiedades o métodos públicos de la clase con la palabra clave

traceProtean() a las variables privadas y las variables públicas de la clase Protean.

myProtean.traceProtean = function () { trace(myProtean.privateGreeting); // undefined trace(myProtean.publicGreeting); // hello }; myProtean.traceProtean();

this o el nombre de la clase. En el siguiente ejemplo se muestra el intento de acceso del método

Protean deben calificarse

Descripción de los tipos de datos

Los tipos de datos simples son Boolean, int, Null, Number, String, uint y void. Las clases principales de ActionScript también definen los tipos de datos complejos siguientes: Object, Array, Date, Error, Function, RegExp, XML y XMLList.

Tipo de datos Boolean

El tipo de datos Boolean consta de dos valores: true y false. Ningún otro valor es válido para variables de tipo Boolean. El valor predeterminado de una variable booleana declarada pero no inicializada es

false.

Tipo de datos int

El tipo de datos int se almacena internamente como un entero de 32 bits y consta del conjunto de enteros entre

-2.147.483.648 (-2 el tipo de datos Number, que se usaba tanto para enteros como para números de coma flotante. En ActionScript 3.0 se tiene acceso a tipos de bajo nivel para enteros de 32 bits con o sin signo. Si la variable no va a usar números de coma flotante, es más rápido y eficaz utilizar el tipo de datos int en lugar del tipo de datos Number.

Para valores enteros que estén fuera del rango de los valores enteros mínimo y máximo, hay que utilizar el tipo de datos Number, que admite valores entre los valores positivo y negativo de 9.007.199.254.740.992 (valores enteros de 53 bits). El valor predeterminado para variables con tipo de datos int es 0.

) a 2.147.483,647 (231 - 1), ambos incluidos. Las versiones anteriores de ActionScript sólo ofrecían

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Tipo de datos Null

El tipo de datos Null (nulo) tiene un único valor: null. Éste es el valor predeterminado para el tipo de datos String y para todas las clases que definen tipos de datos complejos, incluida la clase Object. Ninguno de los demás tipos de datos simples, como Boolean, Number, int y uint, contienen el valor

null en el valor predeterminado adecuado si intenta asignar null a variables de tipo Boolean, Number, int o uint. Este

null. Flash Player y Adobe AIR convertirán el valor

tipo de datos no se puede utilizar como una anotación de tipo.

Tipo de datos Number

En ActionScript 3.0, el tipo de datos Number representa enteros, enteros sin signo y números de coma flotante. Sin embargo, para maximizar el rendimiento se recomienda utilizar el tipo de datos Number únicamente para valores enteros que ocupen más que los 32 bits que pueden almacenar los tipos de datos flotante. Para almacenar un número de coma flotante se debe incluir una coma decimal en el número. Si se omite un separador decimal, el número se almacenará como un entero.

El tipo de datos Number utiliza el formato de doble precisión de 64 bits especificado en la norma IEEE para aritmética binaria de coma flotante (IEEE-754). Esta norma especifica cómo se almacenan los números de coma flotante utilizando los 64 bits disponibles. Se utiliza un bit para designar si el número es positivo o negativo. El exponente, que se almacena como un número de base 2, utiliza once bits. Los 52 bits restantes se utilizan para almacenar la cifra significativa (también denominada mantisa), que es el número que se eleva a la potencia indicada por el exponente.

int y uint o para números de coma

Al utilizar parte de los bits para almacenar un exponente, el tipo de datos Number puede almacenar números de coma flotante considerablemente más grandes que si se utilizaran todos los bits para la mantisa. Por ejemplo, si el tipo de

datos Number utilizara los 64 bits para almacenar la mantisa, podría almacenar números hasta 2 para almacenar un exponente, el tipo de datos Number puede elevar la mantisa a una potencia de 2

-1. Al utilizar 11 bits

1023

Los valores máximo y mínimo que el tipo Number puede representar se almacenan en propiedades estáticas de la clase Number denominadas

Number.MAX_VALUE == 1.79769313486231e+308 Number.MIN_VALUE == 4.940656458412467e-324

Number.MAX_VALUE y Number.MIN_VALUE.

Aunque este rango de números es enorme, se pierde en precisión. El tipo de datos Number utiliza 52 bits para almacenar la mantisa y, como consecuencia, los números que requieren más de 52 bits para una representación precisa, como la fracción 1/3, son sólo aproximaciones. Si la aplicación requiere precisión absoluta con números decimales, hay que utilizar software que implemente aritmética decimal de coma flotante en lugar de aritmética binaria de coma flotante.

Al almacenar valores enteros con el tipo de datos Number, sólo se utilizarán los 52 bits de la mantisa. El tipo de datos

Number utiliza estos 52 bits y un bit oculto especial para representar enteros entre -9.007.199.254.740.992 (-2

9.007.199.254.740.992 (2

Flash Player y Adobe AIR utilizan el valor

NaN no sólo como el valor predeterminado para las variables de tipo Number,

) y

sino también como resultado de cualquier operación que debiera devolver un número y no lo haga. Por ejemplo, si se intenta calcular la raíz cuadrada de un número negativo, el resultado será infinito positivo e infinito negativo

NaN. Otros valores especiales de Number son

Nota: el resultado de la división por 0 sólo es NaN si el divisor también es 0. La división por 0 produce infinity cuando el dividendo es positivo o

-infinity cuando el dividendo es negativo.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Tipo de datos String

El tipo de datos String representa una secuencia de caracteres de 16 bits. Las cadenas se almacenan internamente como caracteres Unicode empleando el formato UTF-16. Las cadenas son valores inmutables, igual que en el lenguaje de programación Java. Una operación sobre un valor de cadena (String) devuelve una nueva instancia de la cadena. El valor predeterminado de una variable declarada con el tipo de datos String es la cadena vacía (

""), aunque ambos representan la ausencia de caracteres.

null. El valor null no es lo mismo que

Tipo de datos uint

El tipo de datos uint se almacena internamente como un entero sin signo de 32 bits y consta del conjunto de enteros

entre 0 y 4.294.967.295 (2

- 1), ambos incluidos. El tipo de datos uint debe utilizarse en circunstancias especiales que requieran enteros no negativos. Por ejemplo, se debe utilizar el tipo de datos uint para representar valores de colores de píxeles, ya que el tipo de datos int tiene un bit de signo interno que no es apropiado para procesar valores de colores. Para valores enteros más grandes que el valor uint máximo, se debe utilizar el tipo de datos Number, que puede procesar valores enteros de 53 bits. El valor predeterminado para variables con tipo de datos uint es 0.

Tipo de datos Void

El tipo de datos void tiene un único valor: undefined. En las versiones anteriores de ActionScript, undefined era el valor predeterminado de las instancias de la clase Object. En ActionScript 3.0, el valor predeterminado de las instancias de Object es convertirán el valor en sin tipo son variables que no tienen anotación de tipo o utilizan el símbolo de asterisco ( Sólo se puede usar

null. Si se intenta asignar el valor undefined a una instancia de la clase Object, Flash Player o Adobe AIR

null. Sólo se puede asignar un valor undefined a variables que no tienen tipo. Las variables

*) como anotación de tipo.

void como anotación de tipo devuelto.

Tipo de datos Object

El tipo de datos Object (objeto) se define mediante la clase Object. La clase Object constituye la clase base para todas las definiciones de clase en ActionScript. La versión del tipo de datos Object en ActionScript 3.0 difiere de la de versiones anteriores en tres aspectos. En primer lugar, el tipo de datos Object ya no es el tipo de datos predeterminado que se asigna a las variables sin anotación de tipo. En segundo lugar, el tipo de datos Object ya no incluye el valor

undefined que se utilizaba como valor predeterminado de las instancias de Object. Por último, en ActionScript 3.0,

el valor predeterminado de las instancias de la clase Object es

En versiones anteriores de ActionScript, a una variable sin anotación de tipo se le asignaba automáticamente el tipo de datos Object. Esto ya no es así en ActionScript 3.0, que incluye el concepto de variable sin tipo. Ahora se considera que las variables sin anotación de tipo no tienen tipo. Si se prefiere dejar claro a los lectores del código que la intención es dejar una variable sin tipo, se puede utilizar el nuevo símbolo de asterisco ( omitir una anotación de tipo. En el siguiente ejemplo se muestran dos sentencias equivalentes que declaran una variable sin tipo

var x var x:*

Sólo las variables sin tipo pueden contener el valor undefined. Si se intenta asignar el valor undefined a una variable que tiene un tipo de datos, Flash Player o Adobe AIR convertirán el valor dicho tipo de datos. En el caso de las instancias del tipo de datos Object, el valor predeterminado es Flash Player o Adobe AIR convertirán el valor

undefined en null si intenta asignar undefined a una instancia

Object.

null.

*) para la anotación de tipo, que equivale a

undefined en el valor predeterminado de

null, según el cual

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Conversiones de tipos

Se dice que se produce una conversión de tipo cuando se transforma un valor en otro valor con un tipo de datos distinto. Las conversiones de tipo pueden ser implícitas o explícitas. La conversión implícita, también denominada coerción, en ocasiones es realizada en tiempo de ejecución por Flash Player o Adobe AIR. Por ejemplo, si a una variable del tipo de datos Boolean se le asigna el valor 2, Flash Player o Adobe AIR convertirán este valor en el valor booleano

true antes de asignar el valor a la variable. La conversión explícita, también denominada conversión, se produce

cuando el código ordena al compilador que trate una variable de un tipo de datos como si perteneciera a un tipo de datos distinto. Si se usan valores simples, la conversión convierte realmente los valores de un tipo de datos a otro. Para convertir un objeto a otro tipo, hay que incluir el nombre del objeto entre paréntesis y anteponerle el nombre del nuevo tipo. Por ejemplo, el siguiente código toma un valor booleano y lo convierte en un entero:

var myBoolean:Boolean = true; var myINT:int = int(myBoolean); trace(myINT); // 1

Conversiones implícitas

Las conversiones implícitas se realizan en tiempo de ejecución en algunos contextos:

• En sentencias de asignación

• Cuando se pasan valores como argumentos de función

• Cuando se devuelven valores desde funciones

• En expresiones que utilizan determinados operadores, como el operador suma (+)

Para tipos definidos por el usuario, las conversiones implícitas se realizan correctamente cuando el valor que se va a convertir es una instancia de la clase de destino o una clase derivada de la clase de destino. Si una conversión implícita no se realiza correctamente, se producirá un error. Por ejemplo, el código siguiente contiene una conversión implícita correcta y otra incorrecta:

class A {} class B extends A {}

var objA:A = new A(); var objB:B = new B(); var arr:Array = new Array();

objA = objB; // Conversion succeeds. objB = arr; // Conversion fails.

Para tipos simples, las conversiones implícitas se realizan llamando a los mismos algoritmos internos de conversión que utilizan las funciones de conversión explícita. En las secciones siguientes se describen en mayor detalle estas conversiones de tipos simples.

Conversiones explícitas

Resulta útil usar conversiones explícitas cuando se compila en modo estricto, ya que a veces no se desea que una discordancia de tipos genere un error en tiempo de compilación. Esto puede ocurrir, por ejemplo, cuando se sabe que la coerción convertirá los valores correctamente en tiempo de ejecución. Por ejemplo, al trabajar con datos recibidos desde un formulario, puede ser interesante basarse en la coerción para convertir determinados valores de cadena en valores numéricos. El código siguiente genera un error de tiempo de compilación aunque se ejecuta correctamente en modo estándar:

var quantityField:String = "3"; var quantity:int = quantityField; // compile time error in strict mode

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Si se desea seguir utilizando el modo estricto pero se quiere convertir la cadena en un entero, se puede utilizar la conversión explícita de la manera siguiente:

var quantityField:String = "3"; var quantity:int = int(quantityField); // Explicit conversion succeeds.

Conversión a int, uint y Number

Cualquier tipo de datos se puede convertir en uno de los tres tipos numéricos siguientes: int, uint y Number. Si por algún motivo Flash Player o Adobe AIR no pueden convertir el número, se asignará el valor predeterminado 0 a los tipos de datos int y uint, y el valor predeterminado de booleano a un número,

var myBoolean:Boolean = true; var myUINT:uint = uint(myBoolean); var myINT:int = int(myBoolean); var myNum:Number = Number(myBoolean); trace(myUINT, myINT, myNum); // 1 1 1 myBoolean = false; myUINT = uint(myBoolean); myINT = int(myBoolean); myNum = Number(myBoolean); trace(myUINT, myINT, myNum); // 0 0 0

true se convierte en el valor 1 y false se convierte en el valor 0.

NaN se asignará al tipo de datos Number. Si se convierte un valor

Los valores de cadena que sólo contienen dígitos pueden convertirse correctamente en uno de los tipos numéricos. Los tipos numéricos también pueden convertir cadenas que parecen números negativos o cadenas que representan un valor hexadecimal (por ejemplo,

0x1A). El proceso de conversión omite los caracteres de espacio en blanco iniciales y

finales del valor de cadena. También se puede convertir cadenas que parecen números de coma flotante mediante

Number(). La inclusión de un separador decimal hace que uint() e int() devuelvan un entero, truncando el

separador decimal y los caracteres que siguen. Por ejemplo, los siguientes valores de cadena pueden convertirse en números:

trace(uint("5")); // 5 trace(uint("-5")); // 4294967291. It wraps around from MAX_VALUE trace(uint(" 27 ")); // 27 trace(uint("3.7")); // 3 trace(int("3.7")); // 3 trace(int("0x1A")); // 26 trace(Number("3.7")); // 3.7

Los valores de cadena que contienen caracteres no numéricos devuelven 0 cuando se convierten con int() o uint(),

NaN cuando se convierten conNumber(). El proceso de conversión omite el espacio en blanco inicial y final, pero

y devuelve 0 o

trace(uint("5a")); // 0 trace(uint("ten")); // 0 trace(uint("17 63")); // 0

NaN si una cadena contiene espacio en blanco separando dos números.

En ActionScript 3.0 la función Number() ya no admite números octales (de base 8). Si se suministra una cadena con un cero inicial a la función en su equivalente decimal. Esto no es así con la función

Number() de ActionScript 2.0, el número se interpreta como un número octal y se convierte

Number() de ActionScript 3.0, que omite el cero inicial. Por

ejemplo, el código siguiente genera resultados distintos cuando se compila con versiones distintas de ActionScript:

trace(Number("044")); // ActionScript 3.0 44 // ActionScript 2.0 36

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

La conversión no es necesaria cuando se asigna un valor de un tipo numérico a una variable de un tipo numérico distinto. Incluso en modo estricto, los tipos numéricos se convierten implícitamente a los otros tipos numéricos. Esto significa que en algunos casos pueden producirse valores inesperados cuando se supera el rango de un tipo. Todos los ejemplos siguientes se compilan en modo estricto, aunque algunos generarán valores inesperados:

var myUInt:uint = -3; // Assign int/Number value to uint variable trace(myUInt); // 4294967293

var myNum:Number = sampleUINT; // Assign int/uint value to Number variable trace(myNum) // 4294967293

var myInt:int = uint.MAX_VALUE + 1; // Assign Number value to uint variable trace(myInt); // 0

myInt = int.MAX_VALUE + 1; // Assign uint/Number value to int variable trace(myInt); // -2147483648

En la tabla siguiente se resumen los resultados de convertir a los tipos de datos Number, int o uint desde otros tipos de datos.

Tipo de datos o valor Resultado de la conversión a Number, int o uint

Boolean Si el valor es

Date Representación interna del objeto Date, que es el número de milisegundos transcurridos desde la medianoche

null

Object Si la instancia es

String Un número si Flash Player o Adobe AIR pueden convertir la cadena en un número; de lo contrario,

undefined Si se convierte a Number, NaN; si se convierte a int o uint, 0.

del 1 de enero de 1970, hora universal.

convierte en Number, o 0 si se convierte a int o uint.

true, 1; de lo contrario, 0.

null y se convierte a Number, NaN; de lo contrario, 0.

NaN si se

Conversión a Boolean

La conversión a Boolean desde cualquiera de los tipos de datos numéricos (uint, int y Number) produce valor numérico es 0 y

true en caso contrario. Para el tipo de datos Number, el valor NaN también produce false. En

false si el

el siguiente ejemplo se muestran los resultados de convertir los números -1, 0 y 1:

var myNum:Number; for (myNum = -1; myNum<2; myNum++) { trace("Boolean(" + myNum +") is " + Boolean(myNum)); }

El resultado del ejemplo muestra que de los tres números, sólo 0 devuelve un valor false:

Boolean(-1) is true Boolean(0) is false Boolean(1) is true

La conversión a Boolean desde un valor String devuelve false si la cadena es null o una cadena vacía (""). De lo contrario, devuelve

true.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

var str1:String; // Uninitialized string is null. trace(Boolean(str1)); // false

var str2:String = ""; // empty string trace(Boolean(str2)); // false

var str3:String = " "; // white space only trace(Boolean(str3)); // true

La conversión a Boolean desde una instancia de la clase Object devuelve false si la instancia es null y true en caso contrario:

var myObj:Object; // Uninitialized object is null. trace(Boolean(myObj)); // false

myObj = new Object(); // instantiate trace(Boolean(myObj)); // true

En modo estricto, las variables Boolean reciben un tratamiento especial en el sentido de que se puede asignar valores de cualquier tipo de datos a una variable Boolean sin realizar una conversión. La coerción implícita desde todos los tipos de datos al tipo de datos Boolean se produce incluso en modo estricto. Es decir, a diferencia de lo que ocurre para casi todos los demás tipos de datos, la conversión a Boolean no es necesaria para evitar errores en modo estricto. Todos los ejemplos siguientes se compilan en modo estricto y se comportan de la manera esperada en tiempo de ejecución:

var myObj:Object = new Object(); // instantiate var bool:Boolean = myObj; trace(bool); // true bool = "random string"; trace(bool); // true bool = new Array(); trace(bool); // true bool = NaN; trace(bool); // false

En la tabla siguiente se resumen los resultados de convertir al tipo de datos Boolean desde otros tipos de datos:

Tipo de datos o valor Resultado de la conversión a Boolean

String

null false

Number, int o uint false si el valor es NaN o 0; true en caso contrario.

Object

false si el valor es null o la cadena vacía (""); true en caso contrario.

false si la instancia es null; true en caso contrario.

Conversión a String

La conversión al tipo de datos String desde cualquiera de los tipos de datos numéricos devuelve una representación del número como una cadena. La conversión al tipo de datos String desde un valor booleano devuelve la cadena si el valor es

La conversión al tipo de datos String desde una instancia de la clase Object devuelve la cadena

null. De lo contrario, la conversión al tipo String de la clase Object devuelve la cadena "[object Object]".

true y devuelve la cadena "false" si el valor es false.

"null" si la instancia

"true"

La conversión a String desde una instancia de la clase Array devuelve una cadena que consta de una lista delimitada por comas de todos los elementos del conjunto. Por ejemplo, la siguiente conversión al tipo de datos String devuelve una cadena que contiene los tres elementos del conjunto:

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

var myArray:Array = ["primary", "secondary", "tertiary"]; trace(String(myArray)); // primary,secondary,tertiary

La conversión a String desde una instancia de la clase Date devuelve una representación de cadena de la fecha que contiene la instancia. Por ejemplo, el ejemplo siguiente devuelve una representación de cadena de la instancia de la clase Date (la salida muestra el resultado para el horario de verano de la costa del Pacífico de EE.UU.):

var myDate:Date = new Date(2005,6,1); trace(String(myDate)); // Fri Jul 1 00:00:00 GMT-0700 2005

En la tabla siguiente se resumen los resultados de convertir al tipo de datos String desde otros tipos de datos.

Tipo de datos o valor Resultado de la conversión a String

Array Una cadena que consta de todos los elementos de conjunto.

Boolean

Date Una representación de cadena del objeto Date.

null "null"

Number, int o uint Una representación de cadena del número.

Object Si la instancia es null,

"true" o "false"

"null"; de lo contrario, "[object Object]".

Sintaxis

La sintaxis de un lenguaje define un conjunto de reglas que deben cumplirse al escribir código ejecutable.

Distinción entre mayúsculas y minúsculas

El lenguaje ActionScript 3.0 distingue mayúsculas de minúsculas. Los identificadores que sólo se diferencien en mayúsculas o minúsculas se considerarán identificadores distintos. Por ejemplo, el código siguiente crea dos variables distintas:

var num1:int; var Num1:int;

Sintaxis con punto

El operador de punto (.) permite acceder a las propiedades y los métodos de un objeto. La sintaxis con punto permite hacer referencia a una propiedad o un método de clase mediante un nombre de instancia, seguido del operador punto y el nombre de la propiedad o el método. Por ejemplo, considere la siguiente definición de clase:

class DotExample { public var prop1:String; public function method1():void {} }

La sintaxis con punto permite acceder a la propiedad prop1 y al método method1() utilizando el nombre de la instancia creada en el código siguiente:

var myDotEx:DotExample = new DotExample(); myDotEx.prop1 = "hello"; myDotEx.method1();

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Se puede utilizar la sintaxis con punto al definir paquetes. El operador punto se utiliza para hacer referencia a paquetes anidados. Por ejemplo, la clase EventDispatcher reside en un paquete denominado events que está anidado dentro del paquete denominado flash. Se puede hacer referencia al paquete events mediante la siguiente expresión:

flash.events

También se puede hacer referencia a la clase EventDispatcher mediante esta expresión:

flash.events.EventDispatcher

Sintaxis con barras diagonales

ActionScript 3.0 no admite la sintaxis con barras diagonales. Esta sintaxis se utilizaba en versiones anteriores de ActionScript para indicar la ruta a un clip de película o una variable.

Literales

Un literal es un valor que aparece directamente en el código. Todos los ejemplos siguientes son literales:

17 "hello"

-3

9.4 null undefined true false

Los literales también pueden agruparse para formar literales compuestos. Los literales de conjunto se escriben entre corchetes (

[]) y utilizan la coma para separar los elementos de conjunto.

Un literal de conjunto puede utilizarse para inicializar un conjunto. En los siguientes ejemplos se muestran dos conjuntos que se inicializan mediante literales de conjunto. Se puede utilizar la sentencia

new y pasar el literal

compuesto como parámetro al constructor de la clase Array, pero también se pueden asignar valores literales directamente al crear instancias de las siguientes clases principales de ActionScript: Object, Array, String, Number, int, uint, XML, XMLList y Boolean.

// Use new statement. var myStrings:Array = new Array(["alpha", "beta", "gamma"]); var myNums:Array = new Array([1,2,3,5,8]);

// Assign literal directly. var myStrings:Array = ["alpha", "beta", "gamma"]; var myNums:Array = [1,2,3,5,8];

Los literales también se pueden utilizar para inicializar un objeto genérico. Un objeto genérico es una instancia de la clase Object. Los literales de objetos se escriben entre llaves ( objeto. Cada propiedad se declara mediante el signo de dos puntos (

{}) y utilizan la coma para separar las propiedades del

:), que separa el nombre de la propiedad del valor

de la propiedad.

Se puede crear un objeto genérico utilizando la sentencia

new y pasar el literal de objeto como parámetro al constructor

de la clase Object, o bien asignar el literal de objeto directamente a la instancia que se está declarando. En el siguiente ejemplo se muestran dos formas de crear un nuevo objeto genérico y se inicializa el objeto con tres propiedades (

propB y propC) establecidas en los valores 1, 2 y 3 respectivamente:

propA,

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

// Use new statement and add properties. var myObject:Object = new Object(); myObject.propA = 1; myObject.propB = 2; myObject.propC = 3;

// Assign literal directly. var myObject:Object = {propA:1, propB:2, propC:3};

Para obtener más información, consulte “Fundamentos de la utilización de cadenas” en la página 144, “Fundamentos

de la utilización de expresiones regulares” en la página 211 e “Inicialización de variables XML” en la página 240.

Signos de punto y coma

Se puede utilizar el signo de punto y coma (;) para finalizar una sentencia. Como alternativa, si se omite el signo de punto y coma, el compilador dará por hecho que cada línea de código representa a una sentencia independiente. Como muchos programadores están acostumbrados a utilizar el signo de punto y coma para indicar el final de una sentencia, el código puede ser más legible si se usan siempre signos de punto y coma para finalizar las sentencias.

El uso del punto y coma para terminar una sentencia permite colocar más de una sentencia en una misma línea, pero esto hará que el código resulte más difícil de leer.

Paréntesis

Los paréntesis (()) se pueden utilizar de tres modos diferentes en ActionScript 3.0. En primer lugar, se pueden utilizar para cambiar el orden de las operaciones de una expresión. Las operaciones agrupadas entre paréntesis siempre se ejecutan primero. Por ejemplo, se utilizan paréntesis para modificar el orden de las operaciones en el código siguiente:

trace(2 + 3 * 4); // 14 trace((2 + 3) * 4); // 20

En segundo lugar, se pueden utilizar paréntesis con el operador coma (,) para evaluar una serie de expresiones y devolver el resultado de la expresión final, como se indica en el siguiente ejemplo:

var a:int = 2; var b:int = 3; trace((a++, b++, a+b)); // 7

Por último, se pueden utilizar paréntesis para pasar uno o más parámetros a funciones o métodos, como se indica en el siguiente ejemplo, que pasa un valor String a la función

trace("hello"); // hello

trace():

Comentarios

El código de ActionScript 3.0 admite dos tipos de comentarios: comentarios de una sola línea y comentarios multilínea. Estos mecanismos para escribir comentarios son similares a los equivalentes de C++ y Java. El compilador omitirá el texto marcado como un comentario.

Los comentarios de una sola línea empiezan por dos caracteres de barra diagonal ( línea. Por ejemplo, el código siguiente contiene un comentario de una sola línea:

//) y continúan hasta el final de la

var someNumber:Number = 3; // a single line comment

Los comentarios multilínea empiezan con una barra diagonal y un asterisco (/*) y terminan con un asterisco y una barra diagonal (

*/).

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

/* This is multiline comment that can span more than one line of code. */

Palabras clave y palabras reservadas

Las palabras reservadas son aquellas que no se pueden utilizar como identificadores en el código porque su uso está reservado para ActionScript. Incluyen las palabras clave léxicas, que son eliminadas del espacio de nombres del programa por el compilador. El compilador notificará un error si se utiliza una palabra clave léxica como un identificador. En la tabla siguiente se muestran las palabras clave léxicas de ActionScript 3.0.

as break case catch

clase const continue default

delete do else extends

false finally for function

if implements import in

instanceof interface internal is

native new null package

private protected public return

super switch this throw

to true try typeof

use var void while

with

Hay un pequeño conjunto de palabras clave, denominadas palabras clave sintácticas, que se pueden utilizar como identificadores, pero que tienen un significado especial en determinados contextos. En la tabla siguiente se muestran las palabras clave sintácticas de ActionScript 3.0.

each get set namespace

include dynamic final native

override static

También hay varios identificadores que a veces se llaman futuras palabras reservadas. ActionScript 3.0 no reserva estos identificadores, aunque el software que incorpore ActionScript 3.0 podrá tratar algunos de ellos como palabras clave. Es posible que pueda utilizar un gran número de estos identificadores en su código, pero Adobe recomienda que no se utilicen ya que pueden aparecer como palabras clave en una versión posterior de dicho lenguaje.

abstract boolean byte cast

char debugger double enum

export float goto intrinsic

long prototype short synchronized

throws to transient type

virtual volatile

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Constantes

ActionScript 3.0 admite la sentencia const, que se puede utilizar para crear constantes. Las constantes son propiedades con un valor fijo que no se puede modificar. Se puede asignar un valor a una constante una sola vez y la asignación debe realizarse cerca de la declaración de la constante. Por ejemplo, si se declara una constante como un miembro de una clase, se puede asignar un valor a esa constante únicamente como parte de la declaración o dentro del constructor de la clase.

El código siguiente declara dos constantes. Se asigna un valor a la primera constante, sentencia de declaración. A la segunda constante,

MAXIMUM, se le asigna un valor en el constructor. Es necesario tener

MINIMUM, como parte de la

en cuenta que este ejemplo sólo compila en modo estándar, ya que el modo estricto sólo permite asignar un valor de constante en tiempo de inicialización.

class A { public const MINIMUM:int = 0; public const MAXIMUM:int;

public function A() { MAXIMUM = 10; } }

var a:A = new A(); trace(a.MINIMUM); // 0 trace(a.MAXIMUM); // 10

Se producirá un error si se intenta asignar de otra manera un valor inicial a una constante. Por ejemplo, si se intenta establecer el valor inicial de

class A { public const MINIMUM:int = 0; public const MAXIMUM:int; }

var a:A = new A(); a["MAXIMUM"] = 10; // run-time error

MAXIMUM fuera de la clase, se producirá un error en tiempo de ejecución.

ActionScript 3.0 define una amplia gama de constantes para su uso. Por convención, en ActionScript las constantes se escriben en mayúsculas y las palabras que las forman se separan mediante el carácter de subrayado (

_). Por ejemplo,

la definición de la clase MouseEvent utiliza esta convención de nomenclatura para sus constantes, cada una de las cuales representa un evento relacionado con una entrada del ratón:

package flash.events { public class MouseEvent extends Event { public static const CLICK:String = "click"; public static const DOUBLE_CLICK:String = "doubleClick"; public static const MOUSE_DOWN:String = "mouseDown"; public static const MOUSE_MOVE:String = "mouseMove"; ... } }

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Operadores

Los operadores son funciones especiales que se aplican a uno o más operandos y devuelven un valor. Un operando es un valor (generalmente un literal, una variable o una expresión) que se usa como entrada de un operador. Por ejemplo, en el código siguiente, los operadores de suma ( para devolver un valor. A continuación, el operador de asignación ( a la variable

var sumNumber:uint = 2 + 3 * 4; // uint = 14

sumNumber.

Los operadores pueden ser unarios, binarios o ternarios. Un operador unario se aplica a un operando. Por ejemplo, el operador de incremento (

++) es un operador unario porque se aplica a un solo operando. Un operador binario se aplica

a dos operandos. Por ejemplo, el operador división ( operandos. Por ejemplo, el operador condicional (

Algunos operadores están sobrecargados, lo que significa que se comportan de distinta manera en función del tipo o la cantidad de operandos que se les pase. El operador suma ( comporta de distinta manera en función del tipo de datos de los operandos. Si ambos operandos son números, el operador suma devuelve la suma de los valores. Si ambos operandos son cadenas, el operador suma devuelve la concatenación de los dos operandos. En el siguiente ejemplo de código se muestra cómo cambia el comportamiento del operador en función de los operandos:

+) y multiplicación (*) se usan con tres operandos literales (2, 3 y 4)

=) usa este valor para asignar el valor devuelto, 14,

/) se aplica a dos operandos. Un operador ternario se aplica a tres

?:) se aplica a tres operandos.

+) es un ejemplo de un operador sobrecargado que se

trace(5 + 5); // 10 trace("5" + "5"); // 55

Los operadores también pueden comportarse de distintas maneras en función del número de operandos suministrados. El operador resta (

-) es la vez un operador unario y un operador binario. Si se le suministra un solo

operando, el operador resta devuelve como resultado la negación del operando. Si se le suministran dos operandos, el operador resta devuelve la diferencia de los operandos. En el siguiente ejemplo se muestra el operador resta usado primero como un operador unario y después como un operador binario.

trace(-3); // -3 trace(7 - 2); // 5

Precedencia y asociatividad de operadores

La precedencia y asociatividad de los operadores determina el orden en que se procesan los operadores. Aunque para aquellos usuarios familiarizados con la programación aritmética puede parecer natural que el compilador procese el operador de multiplicación ( qué operadores debe procesar primero. Dichas instrucciones se conocen colectivamente como precedencia de operadores. ActionScript establece una precedencia de operadores predeterminada que se puede modificar utilizando el operador paréntesis ( anterior para forzar al compilador a procesar el operador suma antes que el operador producto:

var sumNumber:uint = (2 + 3) * 4; // uint == 20

Pueden darse situaciones en las que dos o más operadores con la misma precedencia aparezcan en la misma expresión. En estos casos, el compilador utiliza las reglas de asociatividad para determinar qué operador se procesa primero. Todos los operadores binarios, salvo los operadores de asignación, tienen asociatividad desde la izquierda, lo que significa que los operadores de la izquierda se procesan antes que los operadores de la derecha. Los operadores de asignación y el operador condicional ( la derecha se procesan antes que los operadores de la izquierda.

*) antes que el operador de suma (+), el compilador necesita instrucciones explícitas sobre

()). Por ejemplo, el código siguiente modifica la precedencia predeterminada del ejemplo

?:) tienen asociatividad desde la derecha, lo que significa que los operadores de

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Consideremos, por ejemplo, los operadores menor que (<) y mayor que (>), que tienen la misma precedencia. Si ambos operadores se utilizan en la misma expresión, el operador de la izquierda se procesará en primer lugar porque ambos operadores tienen asociatividad desde la izquierda. Esto significa que las dos sentencias siguientes generan el mismo resultado:

trace(3 > 2 < 1); // false trace((3 > 2) < 1); // false

El operador mayor que se procesa primero, lo que devuelve un valor true, ya que el operando 3 es mayor que el operando 2. A continuación, se pasa el valor

true al operador menor que, junto con el operando 1. El código siguiente

representa este estado intermedio:

trace((true) < 1);

El operador menor que convierte el valor true en el valor numérico 1 y compara dicho valor numérico con el segundo operando 1 para devolver el valor

trace(1 < 1); // false

false (el valor 1 no es menor que 1).

Se puede modificar la asociatividad predeterminada desde la izquierda con el operador paréntesis. Se puede ordenar al compilador que procese primero el operador menor que escribiendo dicho operador y sus operandos entre paréntesis. En el ejemplo siguiente se utiliza el operador paréntesis para producir un resultado diferente utilizando los mismos números que en el ejemplo anterior:

trace(3 > (2 < 1)); // true

El operador menor que se procesa primero, lo que devuelve un valor false, ya que el operando 2 no es menor que el operando 1. A continuación, se pasa el valor

false al operador mayor que, junto con el operando 3. El código siguiente

representa este estado intermedio:

trace(3 > (false));

El operador mayor que convierte el valor false en el valor numérico 0 y compara dicho valor numérico con el otro operando 3 para devolver el valor

trace(3 > 0); // true

true (el valor 3 es mayor que 0).

En la tabla siguiente se muestran los operadores de ActionScript 3.0 por orden decreciente de precedencia. Cada fila de la tabla contiene operadores de la misma precedencia. Cada fila de operadores tiene precedencia superior a la fila que aparece debajo de ella en la tabla.

Grupo Operadores

Primario

Sufijo

Unario

Multiplicativo

Aditivo

Desplazamiento en modo bit

[] {x:y} () f(x) new x.y x[y] <></> @ :: ..

x++ x--

++x --x + - ~ ! delete typeof void

* / %

+ -

<< >> >>>

Relacional

Igualdad

AND en modo bit

XOR en modo bit

< > <= >= as in instanceof is

== != === !==

Grupo Operadores

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

OR en modo bit

AND lógico

OR lógico

Condicional

Asignación

Coma

= *= /= %= += -= <<= >>= >>>= &= ^= |=

Operadores principales

Los operadores principales incluyen los que se utilizan para crear literales Array y Object, agrupar expresiones, llamar a funciones, crear instancias de clase y acceder a propiedades.

Todos los operadores principales, indicados en la tabla siguiente, tienen la misma precedencia. Los operadores que forman parte de la especificación E4X se indican mediante la notación (E4X).

Operador Operación realizada

[]

{x:y}

()

f(x)

Inicializa un conjunto

Inicializa un objeto

Agrupa expresiones

Llama a una función

new

x.y x[y]

<></>

Llama a un constructor

Accede a una propiedad

Inicializa un objeto XMLList (E4X)

Accede a un atributo (E4X)

Califica un nombre (E4X)

Accede a un elemento XML descendiente (E4X)

Operadores de sufijo

Los operadores de sufijo se aplican a un operador para aumentar o reducir el valor. Aunque estos operadores son unarios, se clasifican por separado del resto de los operadores unarios debido a su mayor precedencia y a su comportamiento especial. Al utilizar un operador de sufijo como parte de una expresión mayor, el valor de la expresión se devuelve antes de que se procese el operador de sufijo. Por ejemplo, el siguiente código muestra cómo se devuelve el valor de la expresión

var xNum:Number = 0; trace(xNum++); // 0 trace(xNum); // 1

Todos los operadores de sufijo, indicados en la tabla siguiente, tienen la misma precedencia:

xNum++ antes de que se incremente el valor:

Operador Operación realizada

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Incremento (sufijo)

Decremento (sufijo)

Operadores unarios

Los operadores unarios se aplican a un operando. Los operadores de incremento (++) y decremento (--) de este grupo son operadores de prefijo, lo que significa que aparecen delante del operando en una expresión. Los operadores de prefijo difieren de los correspondientes operadores de sufijo en que la operación de incremento o decremento se realiza antes de que se devuelva el valor de la expresión global. Por ejemplo, el siguiente código muestra cómo se devuelve el valor de la expresión

var xNum:Number = 0; trace(++xNum); // 1 trace(xNum); // 1

Todos los operadores unarios, indicados en la tabla siguiente, tienen la misma precedencia:

Operador Operación realizada

Incremento (prefijo)

Decremento (prefijo)

Unario +

Unario - (negación)

NOT lógico

++xNum después de que se incremente el valor:

delete

typeof

void

NOT en modo bit

Elimina una propiedad

Devuelve información de tipo

Devuelve un valor no definido

Operadores multiplicativos

Los operadores multiplicativos toman dos operandos y realizan cálculos de multiplicación, división o módulo.

Todos los operadores multiplicativos, indicados en la tabla siguiente, tienen la misma precedencia:

Operador Operación realizada

Multiplicación

División

Módulo

Operadores aditivos

Los operadores aditivos se aplican a dos operandos y realizan cálculos de suma y resta. Todos los operadores aditivos, indicados en la tabla siguiente, tienen la misma precedencia:

Operador Operación realizada

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Suma

Resta

Operadores de desplazamiento en modo bit

Los operadores de desplazamiento en modo bit se aplican a dos operandos y desplazan los bits del primer operando según lo especificado por el segundo operando. Todos los operadores de desplazamiento en modo de bit, indicados en la tabla siguiente, tienen la misma precedencia:

Operador Operación realizada

>>>

Desplazamiento a la izquierda en modo bit

Desplazamiento a la derecha en modo bit

Desplazamiento a la derecha en modo bit sin signo

Operadores relacionales

Los operadores relacionales se aplican a dos operandos, comparan sus valores y devuelven un valor booleano. Todos los operadores relacionales, indicados en la tabla siguiente, tienen la misma precedencia:

Operador Operación realizada

Menor que

instanceof

Mayor que

Menor o igual que

Mayor o igual que

Comprueba el tipo de datos

Comprueba las propiedades de objetos

Comprueba una cadena de prototipos

Comprueba el tipo de datos

Operadores de igualdad

Los operadores de igualdad se aplican a dos operandos, comparan sus valores y devuelven un valor booleano. Todos los operadores de igualdad, indicados en la tabla siguiente, tienen la misma precedencia:

Operador Operación realizada

===

!==

Igualdad

Desigualdad

Igualdad estricta

Desigualdad estricta

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Operadores lógicos en modo bit

Los operadores lógicos en modo bit se aplican a dos operandos y realizan operaciones lógicas a nivel de bits. Estos operadores, que tienen una precedencia diferente, se enumeran en la tabla siguiente por orden decreciente de precedencia:

Operador Operación realizada

AND en modo bit

XOR en modo bit

OR en modo bit

Operadores lógicos

Los operadores lógicos se aplican a dos operandos y devuelven un resultado booleano. Estos operadores, que tienen distintas precedencias, se enumeran en la tabla siguiente por orden decreciente de precedencia:

Operador Operación realizada

AND lógico

OR lógico

Operador condicional

El operador condicional es un operador ternario, lo que significa que se aplica a tres operandos. El operador condicional es un método abreviado para aplicar la sentencia condicional

Operador Operación realizada

Condicional

if..else.

Operadores de asignación

Los operadores de asignación se aplican a dos operandos y asignan un valor a un operando en función del valor del otro operando. Todos los operadores de asignación, indicados en la tabla siguiente, tienen la misma precedencia:

Operador Operación realizada

<<=

>>=

>>>=

Asignación

Asignación de multiplicación

Asignación de división

Asignación de módulo

Asignación de suma

Asignación de resta

Asignación de desplazamiento a la izquierda en modo bit

Asignación de desplazamiento a la derecha en modo bit

Asignación de desplazamiento a la derecha en modo bit sin signo

Operador Operación realizada

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Asignación de AND en modo bit

Asignación de XOR en modo bit

Asignación de OR en modo bit

Condicionales

ActionScript 3.0 proporciona tres sentencias condicionales básicas que se pueden usar para controlar el flujo del programa.

if..else

La sentencia condicional if..else permite comprobar una condición y ejecutar un bloque de código si dicha condición existe, o ejecutar un bloque de código alternativo si la condición no existe. Por ejemplo, el siguiente fragmento de código comprueba si el valor de genera una función

if (x > 20) { trace("x is > 20"); } else { trace("x is <= 20"); }

trace() diferente en caso negativo:

x es superior a 20 y genera una función trace() en caso afirmativo o

Si no desea ejecutar un bloque de código alternativo, se puede utilizar la sentencia if sin la sentencia else.

if..else if

Puede comprobar varias condiciones utilizando la sentencia condicional if..else if. Por ejemplo, el siguiente fragmento de código no sólo comprueba si el valor de es negativo:

if (x > 20) { trace("x is > 20"); } else if (x < 0) { trace("x is negative"); }

Si una sentencia if o else va seguida de una sola sentencia, no es necesario escribir dicha sentencia entre llaves. Por ejemplo, en el código siguiente no se usan llaves:

if (x > 0) trace("x is positive"); else if (x < 0) trace("x is negative"); else trace("x is 0");

x es superior a 20, sino que también comprueba si el valor de x

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

No obstante, Adobe recomienda utilizar siempre llaves, ya que podría producirse un comportamiento inesperado si más adelante se añadieran sentencias a una sentencia condicional que no esté escrita entre llaves. Por ejemplo, en el código siguiente el valor de devuelve

var x:int; var positiveNums:int = 0;

if (x > 0) trace("x is positive"); positiveNums++;

trace(positiveNums); // 1

true:

positiveNums aumenta en 1 independientemente de si la evaluación de la condición

switch

La sentencia switch resulta útil si hay varios hilos de ejecución que dependen de la misma expresión de condición. La funcionalidad que proporciona es similar a una serie larga de sentencias más sencilla. En lugar de probar una condición para un valor booleano, la sentencia utiliza el resultado para determinar el bloque de código que debe ejecutarse. Los bloques de código empiezan por una sentencia

case y terminan con una sentencia break. Por ejemplo, la siguiente sentencia switch imprime el día de

la semana en función del número de día devuelto por el método

if..else if, pero su lectura resulta un tanto

switch evalúa una expresión y

Date.getDay():

var someDate:Date = new Date(); var dayNum:uint = someDate.getDay(); switch(dayNum) { case 0: trace("Sunday"); break; case 1: trace("Monday"); break; case 2: trace("Tuesday"); break; case 3: trace("Wednesday"); break; case 4: trace("Thursday"); break; case 5: trace("Friday"); break; case 6: trace("Saturday"); break; default: trace("Out of range"); break; }

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Reproducir indefinidamente

Las sentencias de bucle permiten ejecutar un bloque específico de código repetidamente utilizando una serie de valores o variables. Adobe recomienda escribir siempre el bloque de código entre llaves ( si el bloque de código sólo contiene una sentencia, no es recomendable que lo haga por la misma razón expuesta para las condicionales: aumenta la posibilidad de que las sentencias añadidas posteriormente se excluyan inadvertidamente del bloque de código. Si posteriormente se añade una sentencia que se desea incluir en el bloque de código, pero no se añaden las llaves necesarias, la sentencia no se ejecutará como parte del bucle.

for

El bucle for permite repetir una variable para un rango de valores específico. Debe proporcionar tres expresiones en una sentencia termina la reproducción en bucle y una expresión que cambia el valor de la variable con cada bucle. Por ejemplo, el siguiente código realiza cinco bucles. El valor de la variable los números 0 a 4, cada uno de ellos en su propia línea.

var i:int; for (i = 0; i < 5; i++) { trace(i); }

for: una variable que se establece con un valor inicial, una sentencia condicional que determina cuándo

i comienza en 0 y termina en 4, mientras que la salida son

{}). Aunque puede omitir las llaves

for..in

El bucle for..in recorre las propiedades de un objeto o los elementos de un conjunto. Por ejemplo, se puede utilizar un bucle ningún orden concreto, por lo que pueden aparecer en un orden aparentemente impredecible):

var myObj:Object = {x:20, y:30}; for (var i:String in myObj) { trace(i + ": " + myObj[i]); } // output: // x: 20 // y: 30

También se pueden recorrer los elementos de un conjunto:

var myArray:Array = ["one", "two", "three"]; for (var i:String in myArray) { trace(myArray[i]); } // output: // one // two // three

Lo que no se puede hacer es repetir las propiedades de un objeto si se trata de una instancia de una clase definida por el usuario, a no ser que la clase sea una clase dinámica. Incluso con instancias de clases dinámicas, sólo se pueden repetir las propiedades que se añadan dinámicamente.

for..in para recorrer las propiedades de un objeto genérico (las propiedades de un objeto no se guardan en

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

for each..in

El bucle for each..in recorre los elementos de una colección, que puede estar formada por las etiquetas de un objeto XML o XMLList, los valores de las propiedades de un objeto o los elementos de un conjunto. Por ejemplo, como muestra el fragmento de código siguiente, el bucle un objeto genérico, pero al contrario de lo que ocurre con el bucle

each..in contiene el valor contenido por la propiedad en lugar del nombre de la misma:

var myObj:Object = {x:20, y:30}; for each (var num in myObj) { trace(num); } // output: // 20 // 30

Se puede recorrer un objeto XML o XMLList, como se indica en el siguiente ejemplo:

var myXML:XML = <users> <fname>Jane</fname> <fname>Susan</fname> <fname>John</fname> </users>;

for each (var item in myXML.fname) { trace(item); } /* output Jane Susan John */

for each..in se puede utilizar para recorrer las propiedades de

for..in, la variable de iteración de los bucles for

También se pueden recorrer los elementos de un conjunto, como se indica en este ejemplo:

var myArray:Array = ["one", "two", "three"]; for each (var item in myArray) { trace(item); } // output: // one // two // three

No se pueden recorrer las propiedades de un objeto si el objeto es una instancia de una clase cerrada. Tampoco se pueden recorrer las propiedades fijas (propiedades definidas como parte de una definición de clase), ni siquiera para las instancias de clases dinámicas.

while

El bucle while es como una sentencia if que se repite con tal de que la condición sea true. Por ejemplo, el código siguiente produce el mismo resultado que el ejemplo del bucle

for:

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

var i:int = 0; while (i < 5) { trace(i); i++; }

El lenguaje ActionScript y su sintaxis

Una desventaja que presenta el uso de los bucles while frente a los bucles for es que es más probable escribir un bucle infinito con bucles variable de contador, mientras que el ejemplo de bucle incrementa

while. El código de ejemplo de bucle for no se compila si se omite la expresión que aumenta la

while sí se compila si se omite dicho paso. Sin la expresión que

i, el bucle se convierte en un bucle infinito.

do..while

El bucle do..while es un bucle while que garantiza que el bloque de código se ejecuta al menos una vez, ya que la condición se comprueba después de que se ejecute el bloque de código. El código siguiente muestra un ejemplo simple de un bucle

var i:int = 5; do { trace(i); i++; } while (i < 5); // output: 5

do..while que genera una salida aunque no se cumple la condición:

Funciones

Las funciones son bloques de código que realizan tareas específicas y pueden reutilizarse en el programa. Hay dos tipos de funciones en ActionScript 3.0: métodos y cierres de función. Llamar a una función método o cierre de función depende del contexto en el que se define la función. Una función se denomina método si se define como parte de una definición de clase o se asocia a una instancia de un objeto. Y se denomina cierre de función si se define de cualquier otra manera.

Las funciones siempre han sido muy importantes en ActionScript. Por ejemplo, en ActionScript 1.0 la palabra clave

class no existía, por lo que las "clases" se definían mediante funciones constructoras. Aunque la palabra clave class

se añadió posteriormente al lenguaje, sigue siendo importante comprender a fondo las funciones para aprovechar al máximo las capacidades del lenguaje. Esto puede ser difícil de entender para los programadores que esperan que las funciones de ActionScript se comporten de forma similar a las funciones de lenguajes como C++ o Java. Aunque una definición básica de función e invocación no debe resultar difícil para los programadores con experiencia, algunas de las características más avanzadas de las funciones de ActionScript requieren una explicación.

Fundamentos de la utilización de funciones

En esta sección se ofrece una definición básica de función y se describen las técnicas de invocación.

Invocación de funciones

Para llamar a una función se utiliza su identificador seguido del operador paréntesis ( paréntesis para escribir los parámetros de función que se desea enviar a la función. Por ejemplo, la función que es una función de nivel superior en ActionScript 3.0, se usa por todo el manual:

()). Se puede utilizar el operador

trace(),

trace("Use trace to help debug your script");

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Si se llama a una función sin parámetros, hay que utilizar un par de paréntesis vacíos. Por ejemplo, se puede utilizar el método

var randomNum:Number = Math.random();

Math.random(), que no admite parámetros, para generar un número aleatorio:

Funciones definidas por el usuario

Hay dos formas de definir una función en ActionScript 3.0: se puede utilizar una sentencia de función o una expresión de función. La técnica que se elija dependerá de si se prefiere un estilo de programación más estático o más dinámico. Si se prefiere la programación estática, o en modo estricto, se deben definir las funciones con sentencias de función. Las funciones deben definirse con expresiones de función si existe la necesidad específica de hacerlo. Las expresiones de función se suelen usar en programación dinámica (en modo estándar).

Sentencias de función

Las sentencias de función son la técnica preferida para definir funciones en modo estricto. Una sentencia de función empieza con la palabra clave

function, seguida de:

• El nombre de la función

• Los parámetros, en una lista delimitada por comas y escrita entre paréntesis

• El cuerpo de la función (es decir, el código ActionScript que debe ejecutarse cuando se invoca la función), escrito

entre llaves

Por ejemplo, el código siguiente crea una función que define un parámetro y después invoca la función con la

"hello" como valor del parámetro:

cadena

function traceParameter(aParam:String) { trace(aParam); }

traceParameter("hello"); // hello

Expresiones de función

La segunda manera de declarar una función es utilizar una sentencia de asignación con una expresión de función (también se suele llamar literal de función o función anónima). Éste es un método que requiere escribir más y que se usaba mucho en versiones anteriores de ActionScript.

Una sentencia de asignación con una expresión de función empieza por la palabra clave

var, seguida de:

• El nombre de la función

• El operador dos puntos (:)

• La clase Function para indicar el tipo de datos

• El operador de asignación (=)

• La palabra clave function

• Los parámetros, en una lista delimitada por comas y escrita entre paréntesis

• El cuerpo de la función (es decir, el código ActionScript que debe ejecutarse cuando se invoca la función), escrito

entre llaves

Por ejemplo, el código siguiente declara la función

traceParameter mediante una expresión de función:

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

var traceParameter:Function = function (aParam:String) { trace(aParam); }; traceParameter("hello"); // hello

Tenga en cuenta que, a diferencia de lo que ocurre en una sentencia de función, no se especifica un nombre de función. Otra diferencia importante entre las expresiones de función y las sentencias de función es que una expresión de función es una expresión, no una sentencia. Esto significa que una expresión de función no es independiente, como una sentencia de función. Una expresión de función sólo se puede utilizar como una parte de una sentencia (normalmente una sentencia de asignación). En el siguiente ejemplo se muestra la asignación de una expresión de función a un elemento de conjunto:

var traceArray:Array = new Array(); traceArray[0] = function (aParam:String) { trace(aParam); }; traceArray[0]("hello");

Criterios para elegir entre sentencias y expresiones

Como regla general, se debe utilizar una sentencia de función a menos que circunstancias específicas requieran una expresión. Las sentencias de función son menos detalladas y proporcionan una experiencia más uniforme entre el modo estricto y el modo estándar que las expresiones de función.

También son más fáciles de leer que las sentencias de asignación que contienen expresiones de función. Por otra parte, las sentencias de función hacen que el código sea más conciso; son menos confusas que las expresiones de función, que requieren utilizar las palabras clave

var y function.

Además, proporcionan una experiencia más uniforme entre los dos modos de compilador, ya que permiten utilizar la sintaxis con punto en modo estándar y en modo estricto para invocar un método declarado con una sentencia de función. Esto no es así necesariamente para los métodos declarados con una expresión de función. Por ejemplo, el código siguiente define una clase denominada Example con dos métodos: una expresión de función, y se puede utilizar la sintaxis con punto para invocar el método

class Example { var methodExpression = function() {} function methodStatement() {} }

var myEx:Example = new Example(); myEx.methodExpression(); // error in strict mode; okay in standard mode myEx.methodStatement(); // okay in strict and standard modes

methodStatement(), que se declara con una sentencia de función. En modo estricto no

methodExpression().

methodExpression(), que se declara con

Las expresiones de función se consideran más apropiadas para la programación centrada en el comportamiento dinámico (en tiempo de ejecución). Si se prefiere utilizar el modo estricto, pero también hay que llamar a un método declarado con una expresión de función, se puede utilizar cualquiera de las dos técnicas. En primer lugar, se puede llamar al método utilizando corchetes (

[]) el lugar del operador punto (.). La siguiente llamada a método funciona

correctamente tanto en modo estricto como en modo estándar:

myExample["methodLiteral"]();

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

En segundo lugar, se puede declarar toda la clase como una clase dinámica. Aunque esto permite llamar al método con el operador punto, la desventaja es que se sacrifica parte de la funcionalidad en modo estricto para todas las instancias de la clase. Por ejemplo, el compilador no genera un error si se intenta acceder a una propiedad no definida en una instancia de una clase dinámica.

Hay algunas circunstancias en las que las expresiones de función son útiles. Las expresiones de función se suelen utilizar para crear funciones que se utilizan una sola vez y después se descartan. Otro uso menos común es asociar una función a una propiedad de prototipo. Para obtener más información, consulte “El objeto prototype” en la página 123.

Hay dos diferencias sutiles entre las sentencias de función y las expresiones de función que se deben tener en cuenta al elegir la técnica que se va a utilizar. La primera diferencia es que las expresiones de función no existen de forma independiente como objetos con respecto a la administración de la memoria y la eliminación de datos innecesarios. Es decir, cuando se asigna una expresión de función a otro objeto, como un elemento de conjunto o una propiedad de objeto, se crea la única referencia a esa expresión de función en el código. Si el conjunto o el objeto al que la expresión de función está asociada se salen del ámbito o deja de estar disponible, se dejará de tener acceso a la expresión de función. Si se elimina el conjunto o el objeto, la memoria utilizada por la expresión de función quedará disponible para la eliminación de datos innecesarios, lo que significa que se podrá recuperar esa memoria y reutilizarla para otros propósitos.

En el siguiente ejemplo se muestra que, para una expresión de función, cuando se elimina la propiedad a la que está asignada la expresión, la función deja de estar disponible. La clase Test es dinámica, lo que significa que se puede añadir una propiedad denominada

functionExp() con el operador punto, pero cuando se elimina la propiedad functionExp, la función deja de ser

functionExp que contendrá una expresión de función. Se puede llamar a la función

accesible.

dynamic class Test {} var myTest:Test = new Test();

// function expression myTest.functionExp = function () { trace("Function expression") }; myTest.functionExp(); // Function expression delete myTest.functionExp; myTest.functionExp(); // error

Si, por otra parte, la función se define primero con una sentencia de función, existe como su propio objeto y seguirá existiendo incluso después de que se elimine la propiedad a la que está asociada. El operador propiedades de objetos, por lo que incluso una llamada para eliminar la función

dynamic class Test {} var myTest:Test = new Test();

// function statement function stateFunc() { trace("Function statement") } myTest.statement = stateFunc; myTest.statement(); // Function statement delete myTest.statement; delete stateFunc; // no effect stateFunc();// Function statement myTest.statement(); // error

stateFunc() no funciona.

delete sólo funciona en

La segunda diferencia entre las sentencias de función y las expresiones de función es que las sentencias de función existen en todo el ámbito en que están definidas, incluso en sentencias que aparecen antes que la sentencia de función. En cambio, las expresiones de función sólo están definidas para las sentencias posteriores. Por ejemplo, el código siguiente llama correctamente a la función

scopeTest() antes de que se defina:

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

statementTest(); // statementTest

function statementTest():void { trace("statementTest"); }

El lenguaje ActionScript y su sintaxis

Las expresiones de función no están disponibles antes de ser definidas, por lo que el código siguiente produce un error en tiempo de ejecución:

expressionTest(); // run-time error

var expressionTest:Function = function () { trace("expressionTest"); }

Devolución de valores de funciones

Para devolver un valor de la función se debe utilizar la sentencia

return seguida de la expresión o el valor literal que

se desea devolver. Por ejemplo, el código siguiente devuelve una expresión que representa al parámetro:

function doubleNum(baseNum:int):int { return (baseNum * 2); }

Tenga en cuenta que la sentencia return finaliza la función, por lo que las sentencias que estén por debajo de una sentencia

function doubleNum(baseNum:int):int { return (baseNum * 2); trace("after return"); // This trace statement will not be executed. }

return no se ejecutarán, como se indica a continuación:

En modo estricto se debe devolver un valor del tipo apropiado si se elige especificar un tipo devuelto. Por ejemplo, el código siguiente genera un error en modo estricto porque no devuelve un valor válido:

function doubleNum(baseNum:int):int { trace("after return"); }

Funciones anidadas

Es posible anidar funciones, lo que significa que pueden declararse funciones dentro de otras funciones. Una función anidada sólo está disponible dentro de su función principal, a menos que se pase una referencia a la función a código externo. Por ejemplo, el código siguiente declara dos funciones anidadas dentro de la función

getNameAndVersion():

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Cuando se pasan funciones anidadas a código externo, se pasan como cierres de función, lo que significa que la función retiene todas las definiciones que hubiera en el ámbito cuando se definió la función. Para obtener más información, consulte “Ámbito de una función” en la página 91.

Parámetros de función

ActionScript 3.0 proporciona funcionalidad para los parámetros de función que puede resultar novedosa para los programadores que empiecen a estudiar el lenguaje. Aunque la mayoría de los programadores deberían estar familiarizados con la idea de pasar parámetros por valor o referencia, es posible que el objeto parámetro ... (rest) sean desconocidos para muchos.

arguments y el

Pasar argumentos por valor o por referencia

En muchos lenguajes de programación, es importante comprender la diferencia entre pasar argumentos por valor o por referencia; esta diferencia puede afectar a la manera de diseñar el código.

Al pasar por valor, el valor del argumento se copia en una variable local para usarlo en la función. Al pasar por referencia, sólo se pasa una referencia al argumento, en lugar del valor real. No se realiza ninguna copia del argumento real. En su lugar, se crea una referencia a la variable pasada como argumento y se asigna dicha referencia a una variable local para usarla en la función. Como una referencia a una variable externa a la función, la variable local proporciona la capacidad de cambiar el valor de la variable original.

En ActionScript 3.0, todos los argumentos se pasan por referencia, ya que todos los valores se almacenan como objetos. No obstante, los objetos que pertenecen a los tipos de datos simples, como Boolean, Number, int, uint y String, tienen operadores especiales que hacen que se comporten como si se pasaran por valor. Por ejemplo, el código siguiente crea una función denominada tipo int. Estos parámetros son similares a variables locales declaradas en el cuerpo de la función Cuando se llama a la función con los argumentos referencias a los objetos int representados por comportan como si se pasaran por valor. Aunque

xValue e yValue, los cambios realizados a las variables en el cuerpo de la función generan nuevas copias de

objetos

passPrimitives() que define dos parámetros denominados xParam y yParam, ambos de

passPrimitives().

xValue e yValue, los parámetros xParam e yParam se inicializan con

xValue e yValue. Como los argumentos son valores simples, se

xParam e yParam sólo contienen inicialmente referencias a los

los valores en la memoria.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

function passPrimitives(xParam:int, yParam:int):void { xParam++; yParam++; trace(xParam, yParam); }

var xValue:int = 10; var yValue:int = 15; trace(xValue, yValue);// 10 15 passPrimitives(xValue, yValue); // 11 16 trace(xValue, yValue);// 10 15

El lenguaje ActionScript y su sintaxis

En la función passPrimitives(), los valores de xParam e yParam se incrementan, pero esto no afecta a los valores de

xValue e yValue, como se indica en la última sentencia trace. Esto es así aunque se asigne a los parámetros los

mismos nombres que a las variables,

xValue e yValue, ya que dentro de la función xValue e yValue señalarían nuevas

ubicaciones de la memoria que existen por separado de las variables externas a la función que tienen el mismo nombre.

Todos los demás objetos (es decir, los objetos que no pertenecen a los tipos de datos simples) se pasan siempre por referencia, ya que esto ofrece la capacidad de cambiar el valor de la variable original. Por ejemplo, el código siguiente crea un objeto denominado

passByRef(). Como el objeto no es un tipo simple, no sólo se pasa por referencia, sino que también se mantiene como

objVar con dos propiedades, x e y. El objeto se pasa como un argumento a la función

una referencia. Esto significa que los cambios realizados en los parámetros dentro de la función afectarán a las propiedades del objeto fuera de la función.

function passByRef(objParam:Object):void { objParam.x++; objParam.y++; trace(objParam.x, objParam.y); } var objVar:Object = {x:10, y:15}; trace(objVar.x, objVar.y); // 10 15 passByRef(objVar); // 11 16 trace(objVar.x, objVar.y); // 11 16

El parámetro objParam hace referencia al mismo objeto que la variable objVar global. Como se puede ver en las sentencias objeto

trace del ejemplo, los cambios realizados en las propiedades x e y del objeto objParam se reflejan en el

objVar.

Valores predeterminados de los parámetros

En ActionScript 3.0 se incluye como novedad la capacidad de declarar valores predeterminados de parámetros para una función. Si una llamada a una función con valores predeterminados de parámetros omite un parámetro con valores predeterminados, se utiliza el valor especificado en la definición de la función para ese parámetro. Todos los parámetros con valores predeterminados deben colocarse al final de la lista de parámetros. Los valores asignados como valores predeterminados deben ser constantes de tiempo de compilación. La existencia de un valor predeterminado para un parámetro convierte de forma efectiva a ese parámetro en un parámetro opcional. Un parámetro sin un valor predeterminado se considera un parámetro requerido.

Por ejemplo, el código siguiente crea una función con tres parámetros, dos de los cuales tienen valores predeterminados. Cuando se llama a la función con un solo parámetro, se utilizan los valores predeterminados de los parámetros.

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

function defaultValues(x:int, y:int = 3, z:int = 5):void { trace(x, y, z); } defaultValues(1); // 1 3 5

El lenguaje ActionScript y su sintaxis

El objeto arguments

Cuando se pasan parámetros a una función, se puede utilizar el objeto los parámetros pasados a la función. Algunos aspectos importantes del objeto

arguments para acceder a información sobre

arguments son:

• El objeto arguments es un conjunto que incluye todos los parámetros pasados a la función.

• La propiedad arguments.length notifica el número de parámetros pasados a la función.

• La propiedad arguments.callee proporciona una referencia a la misma función, que resulta útil para llamadas

recursivas a expresiones de función.

Nota: el objeto

arguments no estará disponible si algún parámetro tiene el nombre arguments o si se utiliza el

parámetro ... (rest).

Si se hace referencia al objeto

arguments en el cuerpo de una función, ActionScript 3.0 permite que las llamadas a

funciones incluyan más parámetros que los definidos en la definición de la función, pero generará un error del compilador en modo estricto si el número de parámetros no coincide con el número de parámetros requeridos (y de forma opcional, los parámetros opcionales). Se puede utilizar el conjunto aspect del objeto

arguments para

acceder a cualquier parámetro pasado a la función, independientemente de si ese parámetro está definido en la definición de la función. En el ejemplo siguiente, que sólo compila en modo estándar, se utiliza el conjunto

arguments junto con la propiedad arguments.length para hacer un seguimiento de todos los parámetros

pasados a la función

function traceArgArray(x:int):void { for (var i:uint = 0; i < arguments.length; i++) { trace(arguments[i]); } }

traceArgArray(1, 2, 3);

// output: // 1 // 2 // 3

traceArgArray():

La propiedad arguments.callee se suele utilizar en funciones anónimas para crear recursión. Se puede utilizar para añadir flexibilidad al código. Si el nombre de una función recursiva cambia a lo largo del ciclo de desarrollo, no es necesario preocuparse de cambiar la llamada recursiva en el cuerpo de la función si se utiliza

arguments.callee en lugar del nombre de la función. La propiedad arguments.callee se utiliza en la siguiente

expresión de función para habilitar la recursión:

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

var factorial:Function = function (x:uint) { if(x == 0) { return 1; } else { return (x * arguments.callee(x - 1)); } }

trace(factorial(5)); // 120

Si se utiliza el parámetro ... (rest) en la declaración de la función, el objeto arguments no estará disponible. Hay que acceder a los parámetros a través de los nombres de parámetro declarados.

También hay que procurar no utilizar la cadena

arguments. Por ejemplo, si se vuelve a escribir la función traceArgArray() de forma que se añade un

objeto parámetro lugar de al objeto

function traceArgArray(x:int, arguments:int):void { for (var i:uint = 0; i < arguments.length; i++) { trace(arguments[i]); } }

traceArgArray(1, 2, 3);

// no output

arguments, las referencias a arguments en el cuerpo de la función hacen referencia al parámetro, en

arguments. El siguiente código no produce ningún resultado:

"arguments" como nombre de parámetro, ya que ocultará el

El objeto arguments de versiones anteriores de ActionScript también contenía una propiedad denominada

caller, que es una referencia a la función que llamó a la función actual. La propiedad caller no existe en

ActionScript 3.0, pero si se necesita una referencia a la función que llama, se puede modificar dicha función de forma que pase un parámetro adicional que sea una referencia sí mismo.

El parámetro ...(rest)

ActionScript 3.0 introduce una declaración de un parámetro nuevo que se llama ... (rest). Este parámetro permite especificar un parámetro de tipo conjunto que acepta un número arbitrario de argumentos delimitados por comas. El parámetro puede tener cualquier nombre que no sea una palabra reservada. Este parámetro debe especificarse el último. El uso de este parámetro hace que el objeto la misma funcionalidad que el conjunto similar a la que ofrece

arguments.callee. Hay que asegurarse de que no es necesario utilizar arguments.callee

arguments y la propiedad arguments.length, no proporciona funcionalidad

arguments no esté disponible. Aunque el parámetro ... (rest) ofrece

antes de utilizar el parámetro ... (rest).

En el ejemplo siguiente se reescribe la función

arguments:

traceArgArray() con el parámetro ... (rest) en lugar del objeto

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

function traceArgArray(... args):void { for (var i:uint = 0; i < args.length; i++) { trace(args[i]); } }

traceArgArray(1, 2, 3);

// output: // 1 // 2 // 3

El lenguaje ActionScript y su sintaxis

El parámetro ... (rest) también puede utilizarse con otros parámetros, con tal de que sea el último parámetro de la lista. En el ejemplo siguiente se modifica la función

traceArgArray() de forma que su primer parámetro, x, sea de tipo int

y el segundo parámetro utilice el parámetro ... (rest). La salida omite el primer valor porque el primer parámetro ya no forma parte del conjunto creada por el parámetro ... (rest).

function traceArgArray(x: int, ... args) { for (var i:uint = 0; i < args.length; i++) { trace(args[i]); } }

traceArgArray(1, 2, 3);

// output: // 2 // 3

Funciones como objetos

En ActionScript 3.0 las funciones son objetos. Al crear una función, se crea un objeto que no sólo se puede pasar como un parámetro a otra función, sino que además tiene propiedades y métodos asociados.

Las funciones pasadas como argumentos a otra función se pasan por referencia, no por valor. Al pasar una función como un argumento sólo se utiliza el identificador y no el operador paréntesis que se utiliza para llamar al método. Por ejemplo, el código siguiente pasa una función denominada

addEventListener():

addEventListener(MouseEvent.CLICK, clickListener);

El método Array.sort() también define un parámetro que acepta una función. Para ver un ejemplo de una función de ordenación personalizada que se utiliza como argumento de la función

un conjunto” en la página 167.

clickListener() como un argumento al método

Array.sort(), consulte “Ordenación de

PROGRAMACIÓN CON ACTIONSCRIPT 3.0 PARA FLASH

El lenguaje ActionScript y su sintaxis

Aunque pueda parecer extraño a los programadores sin experiencia en ActionScript, las funciones pueden tener propiedades y métodos, igual que cualquier otro objeto. De hecho, cada función tiene una propiedad de sólo lectura denominada

arguments.length, que notifica el número de argumentos enviados a la función. Debe recordarse que en

length que almacena el número de parámetros definidos para la función. Es distinta de la propiedad

ActionScript el número de argumentos enviados a una función pueden superar el número de parámetros definidos para dicha función. En el ejemplo siguiente, que sólo se compila en modo estándar porque el modo estricto requiere una coincidencia exacta entre el número de argumentos pasados y el número de parámetros definidos, se muestra la diferencia entre las dos propiedades:

// Compiles only in standard mode function traceLength(x:uint, y:uint):void { trace("arguments received: " + arguments.length); trace("arguments expected: " + traceLength.length); }

traceLength(3, 5, 7, 11); /* output: arguments received: 4 arguments expected: 2 */

En modo estándar se pueden definir propiedades de función propias fuera del cuerpo de la función. Las propiedades de función pueden servir como propiedades casi estáticas que permiten guardar el estado de una variable relacionada con la función. Por ejemplo, si se desea hacer un seguimiento del número de veces que se llama a una función determinada. Esta funcionalidad puede ser útil cuando se programa un juego y se desea hacer un seguimiento del número de veces que un usuario utiliza un comando específico, aunque también se podría utilizar una propiedad de clase estática para esto. El ejemplo siguiente, que sólo compila en modo estándar porque el modo estricto no permite añadir propiedades dinámicas a funciones, crea una propiedad de función fuera de la declaración de función e incrementa la propiedad cada vez que se llama a la función:

// Compiles only in standard mode var someFunction:Function = function ():void { someFunction.counter++; }

someFunction.counter = 0;

someFunction(); someFunction(); trace(someFunction.counter); // 2

Ámbito de una función

El ámbito de una función determina no sólo en qué partes de un programa se puede llamar a esa función, sino también a qué definiciones tiene acceso la función. Las mismas reglas de ámbito que se aplican a los identificadores de variable se aplican a los identificadores de función. Una función declarada en el ámbito global estará disponible en todo el código. Por ejemplo, ActionScript 3.0 contiene funciones globales, como disponibles desde cualquier punto del código. Una función anidada (una función declarada dentro de otra función) puede utilizarse en cualquier punto de la función en que se declaró.

isNaN() y parseInt(), que están

Adobe ActionScript - 3.0 Manual de Programación [es]

Specifications and Main Features

Frequently Asked Questions

User Manual

Contenido

Capítulo 1: Información sobre este manual

Utilización de este manual

Acceso a la documentación de ActionScript

Documentación de ActionScript 3.0

Documentación de Flash

Recursos de aprendizaje de ActionScript

Centro de desarrollo de Adobe

Centro de diseño de Adobe

ActionScript

Ventajas de ActionScript 3.0

Novedades de ActionScript 3.0

Funciones del núcleo del lenguaje

Funciones de la API de Flash Player

Compatibilidad con versiones anteriores

Capítulo 3: Introducción a ActionScript

Fundamentos de programación

Para qué sirven los programas informáticos

Variables y constantes

Tipos de datos

Trabajo con objetos

Propiedades

Métodos

Eventos

Gestión básica de eventos

Análisis del proceso de gestión de eventos

Ejemplos de gestión de eventos

Creación de instancias de objetos

Elementos comunes de los programas

Operadores

Comentarios

Control de flujo

Ejemplo: Sitio de muestras de animación

Preparación de la animación para añadirle interactividad

Crear y añadir botones

Escritura del código

Probar la aplicación

Creación de aplicaciones con ActionScript

Opciones para organizar el código

Selección de la herramienta adecuada

Proceso de desarrollo de ActionScript

Creación de clases personalizadas

Estrategias de diseño de una clase

Escritura del código de una clase

Ejemplo: Creación de una aplicación básica

Diseño de una aplicación ActionScript

Creación del proyecto HelloWorld y de la clase Greeter

Añadir código a la clase Greeter

Creación de una aplicación que utilice el código ActionScript

Publicación y prueba de la aplicación ActionScript

Mejora de la aplicación HelloWorld

Ejecución de ejemplos posteriores

Prueba de los listados de código de ejemplo del capítulo

Ejemplos de final de capítulo

Capítulo 4: El lenguaje ActionScript y su sintaxis

Información general sobre el lenguaje

Objetos y clases

Paquetes y espacios de nombres

Paquetes

Creación de paquetes

Importación de paquetes

Espacios de nombres

Variables

Aspectos básicos del ámbito de variables

Valores predeterminados

Tipos de datos

Verificación de tipos

Clases dinámicas

Descripción de los tipos de datos

Tipo de datos Boolean

Tipo de datos int

Tipo de datos Null

Tipo de datos Number

Tipo de datos String

Tipo de datos uint

Tipo de datos Void