Guide de référence ActionScript® 3.0 pour la plate-forme Adobe® Flash®
Accueil  |  Masquer la liste des packages et des classes |  Packages  |  Classes  |  Nouveautés  |  Index  |  Annexes  |  Pourquoi existe-t-il du contenu en anglais ?
Filtres : AIR 30.0 et versions antérieures, Flash Player 30.0 et versions antérieures, Flash Lite 4
Flex 4.6 et versions antérieures, Flash Pro CS6 et versions antérieures
Masquer les filtres
 

Instructions, mots clés et directives 

Packagesx

Niveau supérieur
adobe.utils
air.desktop
air.net
air.update
air.update.events
coldfusion.air
coldfusion.air.errors
coldfusion.air.events
coldfusion.service
coldfusion.service.events
coldfusion.service.mxml
com.adobe.acm.solutions.authoring.domain.extensions
com.adobe.acm.solutions.ccr.domain.extensions
com.adobe.consulting.pst.vo
com.adobe.dct.component
com.adobe.dct.component.datadictionary
com.adobe.dct.component.datadictionaryElement
com.adobe.dct.component.dataElementsPanel
com.adobe.dct.component.toolbars
com.adobe.dct.event
com.adobe.dct.exp
com.adobe.dct.model
com.adobe.dct.service
com.adobe.dct.service.provider
com.adobe.dct.transfer
com.adobe.dct.util
com.adobe.dct.view
com.adobe.ep.taskmanagement.domain
com.adobe.ep.taskmanagement.event
com.adobe.ep.taskmanagement.filter
com.adobe.ep.taskmanagement.services
com.adobe.ep.taskmanagement.util
com.adobe.ep.ux.attachmentlist.component
com.adobe.ep.ux.attachmentlist.domain
com.adobe.ep.ux.attachmentlist.domain.events
com.adobe.ep.ux.attachmentlist.domain.renderers
com.adobe.ep.ux.attachmentlist.skin
com.adobe.ep.ux.attachmentlist.skin.renderers
com.adobe.ep.ux.content.event
com.adobe.ep.ux.content.factory
com.adobe.ep.ux.content.handlers
com.adobe.ep.ux.content.managers
com.adobe.ep.ux.content.model.asset
com.adobe.ep.ux.content.model.preview
com.adobe.ep.ux.content.model.relation
com.adobe.ep.ux.content.model.search
com.adobe.ep.ux.content.model.toolbar
com.adobe.ep.ux.content.search
com.adobe.ep.ux.content.services
com.adobe.ep.ux.content.services.load
com.adobe.ep.ux.content.services.permissions
com.adobe.ep.ux.content.services.preview
com.adobe.ep.ux.content.services.providers
com.adobe.ep.ux.content.services.query
com.adobe.ep.ux.content.services.relationships
com.adobe.ep.ux.content.services.search.lccontent
com.adobe.ep.ux.content.services.version
com.adobe.ep.ux.content.view
com.adobe.ep.ux.content.view.components.activate
com.adobe.ep.ux.content.view.components.grid
com.adobe.ep.ux.content.view.components.grid.hover
com.adobe.ep.ux.content.view.components.grid.hover.component
com.adobe.ep.ux.content.view.components.grid.renderers
com.adobe.ep.ux.content.view.components.relationships
com.adobe.ep.ux.content.view.components.review
com.adobe.ep.ux.content.view.components.search.renderers
com.adobe.ep.ux.content.view.components.searchpod
com.adobe.ep.ux.content.view.components.toolbar
com.adobe.ep.ux.content.view.components.toolbar.controlRenderers
com.adobe.ep.ux.content.view.components.version
com.adobe.ep.ux.documentsubmit.component
com.adobe.ep.ux.documentsubmit.domain
com.adobe.ep.ux.documentsubmit.skin
com.adobe.ep.ux.taskaction.component
com.adobe.ep.ux.taskaction.domain
com.adobe.ep.ux.taskaction.domain.events
com.adobe.ep.ux.taskaction.skin
com.adobe.ep.ux.taskdetails.component
com.adobe.ep.ux.taskdetails.domain
com.adobe.ep.ux.taskdetails.skin
com.adobe.ep.ux.tasklist.component
com.adobe.ep.ux.tasklist.domain
com.adobe.ep.ux.tasklist.skin
com.adobe.ep.ux.webdocumentviewer.domain
com.adobe.exm.expression
com.adobe.exm.expression.error
com.adobe.exm.expression.event
com.adobe.exm.expression.impl
com.adobe.fiber.runtime.lib
com.adobe.fiber.services
com.adobe.fiber.services.wrapper
com.adobe.fiber.styles
com.adobe.fiber.util
com.adobe.fiber.valueobjects
com.adobe.gravity.binding
com.adobe.gravity.context
com.adobe.gravity.flex.bundleloader
com.adobe.gravity.flex.progress
com.adobe.gravity.flex.serviceloader
com.adobe.gravity.framework
com.adobe.gravity.init
com.adobe.gravity.service.bundleloader
com.adobe.gravity.service.logging
com.adobe.gravity.service.manifest
com.adobe.gravity.service.progress
com.adobe.gravity.tracker
com.adobe.gravity.ui
com.adobe.gravity.utility
com.adobe.gravity.utility.async
com.adobe.gravity.utility.error
com.adobe.gravity.utility.events
com.adobe.gravity.utility.factory
com.adobe.gravity.utility.flex.async
com.adobe.gravity.utility.logging
com.adobe.gravity.utility.message
com.adobe.gravity.utility.sequence
com.adobe.gravity.utility.url
com.adobe.guides.control
com.adobe.guides.domain
com.adobe.guides.i18n
com.adobe.guides.spark.components.skins
com.adobe.guides.spark.components.skins.mx
com.adobe.guides.spark.headers.components
com.adobe.guides.spark.headers.skins
com.adobe.guides.spark.layouts.components
com.adobe.guides.spark.layouts.skins
com.adobe.guides.spark.navigators.components
com.adobe.guides.spark.navigators.renderers
com.adobe.guides.spark.navigators.skins
com.adobe.guides.spark.util
com.adobe.guides.spark.wrappers.components
com.adobe.guides.spark.wrappers.skins
com.adobe.guides.submit
com.adobe.icc.dc.domain
com.adobe.icc.dc.domain.factory
com.adobe.icc.editors.events
com.adobe.icc.editors.handlers
com.adobe.icc.editors.managers
com.adobe.icc.editors.model
com.adobe.icc.editors.model.config
com.adobe.icc.editors.model.el
com.adobe.icc.editors.model.el.operands
com.adobe.icc.editors.model.el.operators
com.adobe.icc.enum
com.adobe.icc.external.dc
com.adobe.icc.obj
com.adobe.icc.services
com.adobe.icc.services.category
com.adobe.icc.services.config
com.adobe.icc.services.download
com.adobe.icc.services.export
com.adobe.icc.services.external
com.adobe.icc.services.formbridge
com.adobe.icc.services.fragmentlayout
com.adobe.icc.services.layout
com.adobe.icc.services.letter
com.adobe.icc.services.locator
com.adobe.icc.services.module
com.adobe.icc.services.render
com.adobe.icc.services.submit
com.adobe.icc.services.user
com.adobe.icc.token
com.adobe.icc.vo
com.adobe.icc.vo.render
com.adobe.icomm.assetplacement.controller
com.adobe.icomm.assetplacement.controller.utils
com.adobe.icomm.assetplacement.data
com.adobe.icomm.assetplacement.model
com.adobe.livecycle.assetmanager.client
com.adobe.livecycle.assetmanager.client.event
com.adobe.livecycle.assetmanager.client.handler
com.adobe.livecycle.assetmanager.client.managers
com.adobe.livecycle.assetmanager.client.model
com.adobe.livecycle.assetmanager.client.model.cms
com.adobe.livecycle.assetmanager.client.service
com.adobe.livecycle.assetmanager.client.service.search
com.adobe.livecycle.assetmanager.client.service.search.cms
com.adobe.livecycle.assetmanager.client.utils
com.adobe.livecycle.content
com.adobe.livecycle.rca.model
com.adobe.livecycle.rca.model.constant
com.adobe.livecycle.rca.model.document
com.adobe.livecycle.rca.model.participant
com.adobe.livecycle.rca.model.reminder
com.adobe.livecycle.rca.model.stage
com.adobe.livecycle.rca.service
com.adobe.livecycle.rca.service.core
com.adobe.livecycle.rca.service.core.delegate
com.adobe.livecycle.rca.service.process
com.adobe.livecycle.rca.service.process.delegate
com.adobe.livecycle.rca.token
com.adobe.livecycle.ria.security.api
com.adobe.livecycle.ria.security.service
com.adobe.mosaic.layouts
com.adobe.mosaic.layouts.dragAndDrop
com.adobe.mosaic.layouts.interfaces
com.adobe.mosaic.mxml
com.adobe.mosaic.om.constants
com.adobe.mosaic.om.events
com.adobe.mosaic.om.impl
com.adobe.mosaic.om.interfaces
com.adobe.mosaic.skinning
com.adobe.mosaic.sparklib.editors
com.adobe.mosaic.sparklib.optionMenu
com.adobe.mosaic.sparklib.scrollableMenu
com.adobe.mosaic.sparklib.scrollableMenu.skins
com.adobe.mosaic.sparklib.tabLayout
com.adobe.mosaic.sparklib.tabLayout.events
com.adobe.mosaic.sparklib.tabLayout.layouts
com.adobe.mosaic.sparklib.tabLayout.skins
com.adobe.mosaic.sparklib.text
com.adobe.mosaic.sparklib.util
com.adobe.solutions.acm.authoring.presentation
com.adobe.solutions.acm.authoring.presentation.actionbar
com.adobe.solutions.acm.authoring.presentation.common
com.adobe.solutions.acm.authoring.presentation.events
com.adobe.solutions.acm.authoring.presentation.fragment
com.adobe.solutions.acm.authoring.presentation.letter
com.adobe.solutions.acm.authoring.presentation.letter.data
com.adobe.solutions.acm.authoring.presentation.preview
com.adobe.solutions.acm.authoring.presentation.rte
com.adobe.solutions.acm.ccr.presentation
com.adobe.solutions.acm.ccr.presentation.contentcapture
com.adobe.solutions.acm.ccr.presentation.contentcapture.events
com.adobe.solutions.acm.ccr.presentation.contentcapture.preview
com.adobe.solutions.acm.ccr.presentation.datacapture
com.adobe.solutions.acm.ccr.presentation.datacapture.renderers
com.adobe.solutions.acm.ccr.presentation.pdf
com.adobe.solutions.exm
com.adobe.solutions.exm.authoring
com.adobe.solutions.exm.authoring.components.controls
com.adobe.solutions.exm.authoring.components.toolbars
com.adobe.solutions.exm.authoring.domain
com.adobe.solutions.exm.authoring.domain.expression
com.adobe.solutions.exm.authoring.domain.impl
com.adobe.solutions.exm.authoring.domain.method
com.adobe.solutions.exm.authoring.domain.variable
com.adobe.solutions.exm.authoring.enum
com.adobe.solutions.exm.authoring.events
com.adobe.solutions.exm.authoring.model
com.adobe.solutions.exm.authoring.renderer
com.adobe.solutions.exm.authoring.view
com.adobe.solutions.exm.expression
com.adobe.solutions.exm.impl
com.adobe.solutions.exm.impl.method
com.adobe.solutions.exm.method
com.adobe.solutions.exm.mock
com.adobe.solutions.exm.mock.method
com.adobe.solutions.exm.runtime
com.adobe.solutions.exm.runtime.impl
com.adobe.solutions.exm.variable
com.adobe.solutions.prm.constant
com.adobe.solutions.prm.domain
com.adobe.solutions.prm.domain.factory
com.adobe.solutions.prm.domain.impl
com.adobe.solutions.prm.domain.manager
com.adobe.solutions.prm.presentation.asset
com.adobe.solutions.prm.presentation.constant
com.adobe.solutions.prm.presentation.document
com.adobe.solutions.prm.presentation.event
com.adobe.solutions.prm.presentation.file
com.adobe.solutions.prm.presentation.project
com.adobe.solutions.prm.presentation.team
com.adobe.solutions.prm.presentation.util
com.adobe.solutions.prm.service
com.adobe.solutions.prm.services.impl
com.adobe.solutions.prm.vo
com.adobe.solutions.rca.constant
com.adobe.solutions.rca.domain
com.adobe.solutions.rca.domain.common
com.adobe.solutions.rca.domain.factory
com.adobe.solutions.rca.domain.impl
com.adobe.solutions.rca.domain.impl.manager
com.adobe.solutions.rca.domain.manager
com.adobe.solutions.rca.presentation
com.adobe.solutions.rca.presentation.comment
com.adobe.solutions.rca.presentation.constant
com.adobe.solutions.rca.presentation.event
com.adobe.solutions.rca.presentation.gantt
com.adobe.solutions.rca.presentation.gantt.ruler
com.adobe.solutions.rca.presentation.template
com.adobe.solutions.rca.presentation.template.audit
com.adobe.solutions.rca.presentation.template.definition
com.adobe.solutions.rca.presentation.template.documents
com.adobe.solutions.rca.presentation.template.stages
com.adobe.solutions.rca.presentation.util
com.adobe.solutions.rca.service
com.adobe.solutions.rca.services.impl
com.adobe.solutions.rca.vo
com.adobe.solutions.rca.vo.um
com.adobe.viewsource
fl.accessibility
fl.containers
fl.controls
fl.controls.dataGridClasses
fl.controls.listClasses
fl.controls.progressBarClasses
fl.core
fl.data
fl.display
fl.events
fl.ik
fl.lang
fl.livepreview
fl.managers
fl.motion
fl.motion.easing
fl.rsl
fl.text
fl.transitions
fl.transitions.easing
fl.video
flash.accessibility
flash.concurrent
flash.crypto
flash.data
flash.desktop
flash.display
flash.display3D
flash.display3D.textures
flash.errors
flash.events
flash.external
flash.filesystem
flash.filters
flash.geom
flash.globalization
flash.html
flash.media
flash.net
flash.net.dns
flash.net.drm
flash.notifications
flash.permissions
flash.printing
flash.profiler
flash.sampler
flash.security
flash.sensors
flash.system
flash.text
flash.text.engine
flash.text.ime
flash.ui
flash.utils
flash.xml
flashx.textLayout
flashx.textLayout.compose
flashx.textLayout.container
flashx.textLayout.conversion
flashx.textLayout.edit
flashx.textLayout.elements
flashx.textLayout.events
flashx.textLayout.factory
flashx.textLayout.formats
flashx.textLayout.operations
flashx.textLayout.utils
flashx.undo
ga.controls
ga.layouts
ga.model
ga.uiComponents
ga.util
ga.views
ga.wrappers
lc.foundation
lc.foundation.domain
lc.foundation.events
lc.foundation.ui
lc.foundation.util
lc.preloader
lc.procmgmt
lc.procmgmt.commands
lc.procmgmt.domain
lc.procmgmt.events
lc.procmgmt.formbridge
lc.procmgmt.impl
lc.procmgmt.ui.attachments
lc.procmgmt.ui.controls
lc.procmgmt.ui.controls.card
lc.procmgmt.ui.controls.renderer
lc.procmgmt.ui.help
lc.procmgmt.ui.layout
lc.procmgmt.ui.presentationmodel
lc.procmgmt.ui.process
lc.procmgmt.ui.search
lc.procmgmt.ui.startpoint
lc.procmgmt.ui.task
lc.procmgmt.ui.task.form
lc.procmgmt.ui.task.form.commands
lc.procmgmt.ui.tracking
mx.accessibility
mx.automation
mx.automation.air
mx.automation.delegates
mx.automation.delegates.advancedDataGrid
mx.automation.delegates.charts
mx.automation.delegates.containers
mx.automation.delegates.controls
mx.automation.delegates.controls.dataGridClasses
mx.automation.delegates.controls.fileSystemClasses
mx.automation.delegates.core
mx.automation.delegates.flashflexkit
mx.automation.events
mx.binding
mx.binding.utils
mx.charts
mx.charts.chartClasses
mx.charts.effects
mx.charts.effects.effectClasses
mx.charts.events
mx.charts.renderers
mx.charts.series
mx.charts.series.items
mx.charts.series.renderData
mx.charts.styles
mx.collections
mx.collections.errors
mx.containers
mx.containers.accordionClasses
mx.containers.dividedBoxClasses
mx.containers.errors
mx.containers.utilityClasses
mx.controls
mx.controls.advancedDataGridClasses
mx.controls.dataGridClasses
mx.controls.listClasses
mx.controls.menuClasses
mx.controls.olapDataGridClasses
mx.controls.scrollClasses
mx.controls.sliderClasses
mx.controls.textClasses
mx.controls.treeClasses
mx.controls.videoClasses
mx.core
mx.core.windowClasses
mx.data
mx.data.crypto
mx.data.errors
mx.data.events
mx.data.messages
mx.data.mxml
mx.data.offline.errors
mx.data.utils
mx.effects
mx.effects.easing
mx.effects.effectClasses
mx.events
mx.filters
mx.flash
mx.formatters
mx.geom
mx.graphics
mx.graphics.codec
mx.graphics.shaderClasses
mx.logging
mx.logging.errors
mx.logging.targets
mx.managers
mx.messaging
mx.messaging.channels
mx.messaging.config
mx.messaging.errors
mx.messaging.events
mx.messaging.management
mx.messaging.messages
mx.modules
mx.netmon
mx.olap
mx.olap.aggregators
mx.preloaders
mx.printing
mx.resources
mx.rpc
mx.rpc.events
mx.rpc.http
mx.rpc.http.mxml
mx.rpc.livecycle
mx.rpc.mxml
mx.rpc.remoting
mx.rpc.remoting.mxml
mx.rpc.soap
mx.rpc.soap.mxml
mx.rpc.wsdl
mx.rpc.xml
mx.skins
mx.skins.halo
mx.skins.spark
mx.skins.wireframe
mx.skins.wireframe.windowChrome
mx.states
mx.styles
mx.utils
mx.validators
org.osmf.containers
org.osmf.display
org.osmf.elements
org.osmf.events
org.osmf.layout
org.osmf.logging
org.osmf.media
org.osmf.metadata
org.osmf.net
org.osmf.net.dvr
org.osmf.net.httpstreaming
org.osmf.net.metrics
org.osmf.net.qos
org.osmf.net.rtmpstreaming
org.osmf.net.rules
org.osmf.traits
org.osmf.utils
spark.accessibility
spark.automation.delegates
spark.automation.delegates.components
spark.automation.delegates.components.gridClasses
spark.automation.delegates.components.mediaClasses
spark.automation.delegates.components.supportClasses
spark.automation.delegates.skins.spark
spark.automation.events
spark.collections
spark.components
spark.components.calendarClasses
spark.components.gridClasses
spark.components.mediaClasses
spark.components.supportClasses
spark.components.windowClasses
spark.core
spark.effects
spark.effects.animation
spark.effects.easing
spark.effects.interpolation
spark.effects.supportClasses
spark.events
spark.filters
spark.formatters
spark.formatters.supportClasses
spark.globalization
spark.globalization.supportClasses
spark.layouts
spark.layouts.supportClasses
spark.managers
spark.modules
spark.preloaders
spark.primitives
spark.primitives.supportClasses
spark.skins
spark.skins.mobile
spark.skins.mobile.supportClasses
spark.skins.spark
spark.skins.spark.mediaClasses.fullScreen
spark.skins.spark.mediaClasses.normal
spark.skins.spark.windowChrome
spark.skins.wireframe
spark.skins.wireframe.mediaClasses
spark.skins.wireframe.mediaClasses.fullScreen
spark.transitions
spark.utils
spark.validators
spark.validators.supportClasses
xd.core.axm.enterprise.view.components
xd.core.axm.enterprise.view.skins
xd.core.axm.view.components
xd.core.axm.view.components.support

Eléments du langage

Constantes globales
Fonctions globales
Opérateurs
Instructions, mots clés et directives
Types spéciaux

Annexes

Nouveautés
Erreurs de compilation
Avertissements du compilateur
Erreurs d’exécution
Migration vers ActionScript 3
Jeux de caractères pris en charge
Balises MXML uniquement
Eléments XML de mouvement
Balises Timed Text
Liste des éléments déconseillés
Constantes d’implémentation d’accessibilité
Utilisation des exemples de code ActionScript
Informations juridiques

Classes x

AAAARecord    
AbandonCommand
ABRUtils
AbstractConsumer
AbstractEntityMetadata
AbstractEvent
AbstractInvoker
AbstractMessage
AbstractOperation
AbstractOperation
AbstractParticipant
AbstractProducer
AbstractSearchFilterVO
AbstractService
AbstractServiceWrapper
AbstractStage
AbstractTarget
AbstractWebService
AccConst
Accelerometer
AccelerometerEvent
Accessibility
AccessibilityImplementation
AccessibilityProperties
AccessibleButton
AccessibleText
AccessPrivileges
AccImpl
AccImpl
Accordion
AccordionAutomationImpl
AccordionHeader
AccordionHeaderAccImpl
AccordionHeaderSkin
AccordionHeaderSkin
AccordionHeaderSkin
AccordionNav
AccordionSkin
AcknowledgeMessage
ACMRelationshipManager
ActionBar
ActionBar    
ActionBarButtonSkinBase
ActionBarDefaultButtonAppearance    
ActionBarSkin    
ActionEffectInstance
ActionRenderer
ActionScriptVersion
ActionSelectedEvent
ActivationBrowser
ActivatorSkin
ActiveContentEvent
ActiveDataEvent
ActivityEvent
ActualBitrateMetric
AddAction
AddActionInstance
AddApprovalStageParticipant
AddAssetPopUp
AddChild
AddChildAction
AddChildActionInstance
AddCreatorDialog
AddItemAction
AddItemActionInstance
AddItems
AddPanelButton
AddPanelEvent
AddRemoveEffectTargetFilter
AddReviewStageParticipant
AddServiceEvent
AddStageParticipant
AddTileEvent
AddViewEvent
AddViewManagerEvent
AdjustColor
AdvanceDataElementsPanel
AdvancedChannelSet
AdvancedDataGrid
AdvancedDataGridAccImpl
AdvancedDataGridAutomationImpl
AdvancedDataGridBase
AdvancedDataGridBaseEx
AdvancedDataGridBaseExAutomationImpl
AdvancedDataGridBaseSelectionData
AdvancedDataGridColumn
AdvancedDataGridColumnGroup
AdvancedDataGridDragProxy
AdvancedDataGridEvent
AdvancedDataGridEventReason
AdvancedDataGridGroupItemRenderer
AdvancedDataGridGroupItemRendererAutomationImpl
AdvancedDataGridHeaderHorizontalSeparator
AdvancedDataGridHeaderInfo
AdvancedDataGridHeaderRenderer
AdvancedDataGridHeaderShiftEvent
AdvancedDataGridItemRenderer
AdvancedDataGridItemRendererAutomationImpl
AdvancedDataGridItemSelectEvent
AdvancedDataGridListData
AdvancedDataGridRendererDescription
AdvancedDataGridRendererProvider
AdvancedDataGridSortItemRenderer
AdvancedListBase
AdvancedListBaseAutomationImpl
AdvancedListBaseContentHolderAutomationImpl
AdvancedSearchPod
AdvancedStyleClient
AfterUpSwitchBufferBandwidthRule
AggregatingToken
AggregatingTokenError
AirDragManagerAutomationHandler
AIREvent    
AirFunctionsHelper
Alert
AlertAccImpl
AlertAutomationImpl
AlertFormatter
AlertFormAutomationImpl
AlignmentArea
AllRuntimeSparkControls
AlternativeAudioEvent
AlternativeAudioTrait
AMFChannel
AndOperator
Animate
AnimateColor
AnimateColorInstance
AnimateFilter
AnimateFilterInstance
AnimateInstance
AnimateProperty
AnimatePropertyInstance
AnimateTransform
AnimateTransform3D
AnimateTransformInstance
AnimateTransitionShader
AnimateTransitionShaderInstance
Animation
Animator
Animator3D
AnimatorBase
AnimatorFactory
AnimatorFactory3D
AnimatorFactoryBase
AnimatorFactoryUniversal
AnimatorUniversal
AnnotationParseEvent
AntiAliasType
Application
Application
Application
ApplicationAutomationImpl
ApplicationBackground
ApplicationConstants
ApplicationControlBar
ApplicationDomain
ApplicationDomainTarget
ApplicationListItem
ApplicationSkin
ApplicationSkin
ApplicationSpecifier
ApplicationTitleBarBackgroundSkin    
ApplicationUpdater    
ApplicationUpdaterUI    
ApplyElementIDOperation
ApplyElementStyleNameOperation
ApplyElementTypeNameOperation
ApplyElementUserStyleOperation
ApplyFormatOperation
ApplyFormatToElementOperation
ApplyLinkOperation
ApplyTCYOperation
ApprovalStage
ApprovalStage
Approver
Approver
ApproverCollection
ApproverStatus
ApproverStatus
ApproverVO
AreaChart
AreaRenderer
AreaSeries
AreaSeriesAutomationImpl
AreaSeriesItem
AreaSeriesRenderData
AreaSet
ARecord    
ArgumentError
arguments
Array
ArrayCollection
ArrayList
ArrayUtil
ArrowDirection    
Asset
AssetAction
AssetAction
AssetActionCompleteEvent
AssetActionCompleteEvent
AssetActionEvent
AssetActionEvent
AssetActionsChangeEvent
AssetDetailsPod
AssetEvent
AssetExplorerServiceDelegate
AssetFocusEvent
AssetHandlerRegistry
AssetHandlerRegistry
AssetManager
AssetManager
AssetManagerView
AssetModel
AssetPod
AssetPropertiesEditor
AssetPropertyDescriptor
AssetPropertyDescriptor
AssetQueryServiceDelegate
AssetReviewPod
AssetTypeDescriptor
AssetTypeDescriptor
AssetValidationEvent
AssetValidationFaultType
AssetVersionPod
AssetVO
Assignment
AssignmentConstants
AsyncErrorEvent
AsyncListView
AsyncMessage
AsyncRequest
AsyncResponder
AsyncToken
AsyncTokenResponder
AsyncTokenWrapper
Attachment
AttachmentCommand
AttachmentEvent
AttachmentHeader
AttachmentHeaderBase
AttachmentHeaderModel
AttachmentIconRenderer
AttachmentIconRendererSkin
AttachmentInfo
AttachmentList
AttachmentList
AttachmentListComponent
AttachmentListModel
AttachmentListSkin
AttachmentLoader
AttachmentPermissions
Attachments
AttachmentsModel
Attribute
AudioDecoder
AudioDeviceManager
AudioElement
AudioEvent
AudioOutputChangeEvent
AudioOutputChangeReason
AudioPlaybackMode    
AudioTrait
AuditActionVO
AuditAttributeVO
AuditLevel
AuditLevel
AuditLevelVO
AuditManager
AuditMetaInfoVO
AuditModuleVO
Auditor
AugmentedError
AugmentedErrorEvent
AuthenticatingApplication
AuthenticationEvent
AuthenticationMethod
AuthFailureCode
AuthOptions
Author
AuthorStatus
AuthorVO
AuthResult
AuthStatus
AutoCapitalize    
AutoLayoutEvent
Automation
AutomationAirEvent
AutomationClass
AutomationDragEvent
AutomationDragEventWithPositionInfo
AutomationError
AutomationEvent
AutomationEventDescriptor
AutomationFlexNativeMenuEvent
AutomationHelper
AutomationID
AutomationIDPart
AutomationManager
AutomationMethodDescriptor
AutomationPropertyDescriptor
AutomationRecordEvent
AutomationReplayEvent
AvailablePropertyIterator
AvailableQualityLevelsMetric
AVDictionaryDataEvent
AverageAggregator
AVHTTPStatusEvent
AVLoader
AVM1Movie
AVNetworkingParams
AVPauseAtPeriodEndEvent
AVTagData
AVURLLoader
AVURLStream
AxisBase
AxisLabel
AxisLabelSet
AxisRenderer
AxisRendererAutomationImpl
AXMAccordion
AXMAccordionItemVO
AXMAccordionSegment
AXMBreadCrumb
AXMButton
AXMButtonBar
AXMButtonBarButton
AXMCheckBox
AXMComboBox
AXMDropDownList
AXMDropDownListBase
AXMEnterpriseAccordionSegmentSkin
AXMEnterpriseAccordionSkin
AXMEnterpriseAssetTabBar
AXMEnterpriseAssetTabBarButtonSkin
AXMEnterpriseAssetTabBarSkin
AXMEnterpriseAssetViewTabBar
AXMEnterpriseAssetViewTabBarButtonSkin
AXMEnterpriseAssetViewTabBarSkin
AXMEnterpriseBreadCrumbButtonSkin
AXMEnterpriseBreadCrumbFocusSkin
AXMEnterpriseBreadCrumbSkin
AXMEnterpriseButtonBarFirstButtonSkin
AXMEnterpriseButtonBarLastButtonSkin
AXMEnterpriseButtonBarMiddleButtonSkin
AXMEnterpriseButtonBarSkin
AXMEnterpriseButtonSkin
AXMEnterpriseCheckboxSkin
AXMEnterpriseCheckboxSmallSkin
AXMEnterpriseClosableTabBarButtonSkin
AXMEnterpriseClosableTabBarSkin
AXMEnterpriseCloseButtonSkin
AXMEnterpriseComboBoxButtonSkin
AXMEnterpriseComboBoxSkin
AXMEnterpriseComboBoxTextInputSkin
AXMEnterpriseDropDownListButtonSkin
AXMEnterpriseDropDownListItemRenderer
AXMEnterpriseDropDownListSkin
AXMEnterpriseFocusSkin
AXMEnterpriseFooterSkin
AXMEnterpriseGridHeaderRenderer
AXMEnterpriseGridSkin
AXMEnterpriseHeaderBarSkin
AXMEnterpriseHeaderButtonBar
AXMEnterpriseHScrollBarLargeSkin
AXMEnterpriseHScrollbarNoControlsSkin
AXMEnterpriseHScrollbarSkin
AXMEnterpriseHScrollbarThumbSkin
AXMEnterpriseHScrollbarTrackNoControlsSkin
AXMEnterpriseHScrollbarTrackSkin
AXMEnterpriseIconButtonSkin
AXMEnterpriseLargeButtonSkin
AXMEnterpriseLargeToggleButtonSkin
AXMEnterpriseNavigationButtonBarSkin
AXMEnterpriseNumericStepperDecrementButtonSkin
AXMEnterpriseNumericStepperIncrementButtonSkin
AXMEnterpriseNumericStepperSkin
AXMEnterpriseNumericStepperTextInputSkin
AXMEnterprisePanelSkin
AXMEnterpriseProgressSpinnerSkin
AXMEnterpriseQuietButtonSkin
AXMEnterpriseQuietHeaderBarButton
AXMEnterpriseQuietLargeButtonSkin
AXMEnterpriseQuietLargeDropDownListButtonSkin
AXMEnterpriseRadioButtonSkin
AXMEnterpriseResizeHandleSkin
AXMEnterpriseScrollDownArrowSkin
AXMEnterpriseScrollLeftArrowSkin
AXMEnterpriseScrollRightArrowSkin
AXMEnterpriseScrollUpArrowSkin
AXMEnterpriseSlideToggleButton
AXMEnterpriseSplitActionButtonSkin
AXMEnterpriseSplitActionPopUpButtonSkin
AXMEnterpriseSplitActionSkin
AXMEnterpriseTabBarButtonSkin
AXMEnterpriseTabBarSkin
AXMEnterpriseTextAreaSkin
AXMEnterpriseTextInputSkin
AXMEnterpriseTitleWindowSkin
AXMEnterpriseToggleButtonSkin
AXMEnterpriseToolBarBottomSkin
AXMEnterpriseToolBarButtonBarFirstButtonSkin
AXMEnterpriseToolBarButtonBarLastButtonSkin
AXMEnterpriseToolBarButtonBarMiddleButtonSkin
AXMEnterpriseToolbarButtonBarSkin
AXMEnterpriseToolBarTopSkin
AXMEnterpriseViewModeButtonBarButtonSkin
AXMEnterpriseViewModeButtonBarSkin
AXMEnterpriseVScrollbarNoControlsSkin
AXMEnterpriseVScrollbarSkin
AXMEnterpriseVScrollbarThumbSkin
AXMEnterpriseVScrollbarTrackNoControlsSkin
AXMEnterpriseVScrollbarTrackSkin
AXMHeaderBar
AXMHScrollBar
AXMLightItemRenderer
AXMList
AXMPopUp
AXMProgressBar
AXMProgressSpinner
AXMResizableContainer
AXMRichTextEditor
AXMRichTextEditorControlBar
AXMScroller
AXMSplitActionButton
AXMSwitch
AXMTabBar
AXMTabBarButton
AXMTitleWindow
AXMToggleButton
AXMToolPopUp
AXMToolPopUpDropDownController
AXMVerticalDivider
AXMVScrollBar

Les instructions sont des éléments de langage qui effectuent ou spécifient une action lors de l’exécution. Par exemple, la fonction return retourne une valeur de résultat pour la fonction dans laquelle elle s’exécute. L’instruction if évalue une condition pour déterminer la prochaine action à prendre. L’instruction switch crée une structure de ramification pour les instructions ActionScript.

Les mots-clés d’attribut modifient la signification des définitions et peuvent être appliqués aux définitions de classe, de variable, de fonction et d’espace de noms. Les mots-clés de définition permettent de définir des entités telles que des variables, fonctions, classes ou interfaces. Les mots-clés d’expression principale représentent des valeurs littérales. Pour une liste des mots réservés, voir Formation à ActionScript 3.0.

Les directives comprennent des instructions et des définitions et peuvent jouer un rôle lors de la compilation ou de l’exécution. Les directives ne correspondant pas à des instructions ou des définitions sont désignées en tant que directives dans le tableau suivant.


  Espaces de noms
 AS3Définit des méthodes et propriétés des classes ActionScript essentielles correspondant à des propriétés fixes et non des propriétés de prototype.
 flash_proxyDéfinit les méthodes de la classe Proxy.
 object_proxyDéfinit les méthodes de la classe ObjectProxy.
  Directives
 default xml namespace La directive default xml namespace définit l’espace de noms par défaut à utiliser pour les objets XML.
 importRend les classes et les packages définis en externe disponibles pour le code.
 includeComprend le contenu du fichier spécifié, comme si les commandes du fichier faisaient partie du script d’appel.
 use namespaceImplique l’ajout des espaces de noms spécifiés à l’ensemble des espaces de noms ouverts.
 Instruction
 breakApparaît au sein d’une boucle (for, for..in, for each..in, do..while ou while) ou dans un bloc d’instructions associées à un cas précis au sein d’une instruction switch.
 caseDéfinit un hyperlien cible pour l’instruction switch.
 continueSaute toutes les instructions restantes dans la boucle de plus bas niveau et commence la prochaine itération de la boucle, comme si le contrôle était arrivé normalement à la fin de la boucle.
 defaultDéfinit le cas par défaut pour une instruction switch.
 do..whileSimilaire à une boucle while, sauf que les instructions sont exécutées une fois avant l’évaluation initiale de la condition.
 elseSpécifie les instructions à exécuter si la condition de l’instruction if retourne la valeur false.
 forEvalue l’expression init (initialisation) une fois, puis commence une séquence de boucle.
 for..inEffectue une itération pour chaque propriété dynamique d’un objet ou chaque élément d’un tableau et exécute l’instruction statement pour chaque propriété ou élément.
 for each..inEffectue une itération pour chaque élément d’une collection et exécute l’instruction statement pour chaque élément.
 ifEvalue une condition pour déterminer la prochaine instruction à exécuter.
 labelAssocie une instruction à un identificateur pouvant être référencé par break ou continue.
 returnRenvoie immédiatement l’exécution à la fonction appelante.
 superInvoque la version superclasse ou parent d’une méthode ou d’un constructeur.
 switchTransfère le contrôle à l’une de plusieurs instructions en fonction de la valeur d’une expression.
 throwGénère ou renvoie une erreur pouvant être traitée ou interceptée par un bloc de code catch.
 try..catch..finallyEncadre un bloc de code pouvant provoquer une erreur, puis répond à l’erreur.
 whileEvalue une condition. Si elle est évaluée à true, exécute une ou plusieurs instructions avant de répéter la boucle et de réévaluer la condition.
 withEtablit un objet par défaut à utiliser pour l’exécution d’une ou plusieurs instructions, ce qui peut permettre de réduire le volume de code à écrire.
 Mot-clé de la définition
 ... (rest) parameterSpécifie qu’une fonction peut accepter un nombre illimité d’arguments séparés par des virgules.
 classDéfinit une classe, permettant d’instancier des objets ayant en commun des méthodes et propriétés personnalisées.
 constSpécifie une constante, variable ne pouvant recevoir de valeur qu’une seule fois.
 extendsDéfinit une classe correspondant à une sous-classe d’une autre classe.
 functionComprend un ensemble d’instructions définies pour l’exécution d’une tâche particulière.
 getDéfinit une méthode getter qui peut être lue comme une propriété.
 implementsSpécifie qu’une classe implémente une ou plusieurs interfaces.
 interfaceDéfinit une interface.
 namespacePermet de contrôler la visibilité des définitions.
 packagePermet d’organiser le code en groupes distincts pouvant être importés par d’autres scripts.
 setDéfinit une méthode setter, qui s’affiche dans l’interface publique en tant que propriété.
 varSpécifie une variable.
 Mot-clé de l’attribut
 dynamicSpécifie que les instances d’une classe peuvent disposer de propriétés dynamiques ajoutées lors de l’exécution.
 finalSpécifie qu’une méthode ne peut pas être remplacée ou qu’une classe ne peut pas être étendue.
 internalSpécifie qu’une classe, une variable, une constante ou une fonction est disponible pour tout appelant au sein du même package.
 nativeSpécifie qu’une fonction ou une méthode est implémentée par Flash Player en code natif.
 overrideSpécifie qu’une méthode remplace une méthode héritée.
 privateSpécifie qu’une variable, une constante, une méthode ou un espace de noms est disponible uniquement pour la classe qui le déclare.
 protectedSpécifie qu’une variable, une constante, une méthode ou un espace de noms est disponible uniquement pour la classe qui le définit, ainsi que pour toutes ses sous-classes éventuelles.
 publicSpécifie qu’une classe, une variable, une constante ou une méthode est disponible pour tout appelant.
 staticSpécifie qu’une variable, une constante ou une méthode appartient à la classe, et non aux instances de la classe.
 Mot-clé de l’expression principale
 falseValeur booléenne false.
 nullUne valeur spéciale qui peut être affectée aux variables ou renvoyée par une fonction en l’absence de données.
 thisRéférence à l’objet contenant une méthode.
 trueValeur booléenne true.
Directives, instructions et mots-clés détaillés
... (rest) parameterMot-clé de la définition
Utilisation

function functionName(parameter0, parameter1, ...rest){ 
	// statement(s) 
} 

Spécifie qu’une fonction peut accepter un nombre illimité d’arguments séparés par des virgules. La liste des arguments devient un tableau disponible dans tout le corps de la fonction. Le nom du tableau est spécifié après les caractères ... dans la déclaration des paramètres. Le paramètre peut porter un nom quelconque, sauf un mot réservé.

Si elle est utilisée avec d’autres paramètres, la déclaration de paramètres ... (rest) doit figurer en dernier paramètre spécifié. Le tableau de paramètres ... (rest) est renseigné uniquement si le nombre d’arguments transmis à la fonction est supérieur au nombre des autres paramètres.

Chaque argument figurant dans la liste d’arguments séparés par des virgules est placé dans un élément du tableau. Si vous transmettez une occurrence de la classe Array, tout le tableau est placé dans un même élément du tableau de paramètres ... (rest).

L’utilisation de ce paramètre rend l’objet arguments indisponible. Le paramètre ... (rest) apporte les mêmes fonctionnalités que le tableau arguments et la propriété arguments.length, mais il n’offre pas de fonctionnalités similaires à celles de arguments.callee. Assurez-vous que vous ne devez pas utiliser arguments.callee avant d’utiliser le paramètre ... (rest).

Paramètres
rest:* — Identificateur représentant le nom du tableau d’arguments transmis à la fonction. Ce paramètre ne doit pas nécessairement être appelé rest. Il peut porter un nom quelconque, sauf un mot-clé. Vous pouvez choisir Array comme type de données du paramètre ... (rest), mais cela risque de prêter à confusion dans la mesure où le paramètre autorise une liste de valeurs séparées par des virgules, ce qui diffère d’une occurrence de la classe Array.

Exemple
Comment utiliser cet exemple
L’exemple suivant utilise le paramètre ... (rest) dans deux fonctions distinctes. La première fonction, traceParams, appelle simplement la fonction trace() sur chacun des arguments du tableau rest. La deuxième fonction, average(), prend la liste d’arguments et retourne la moyenne. La deuxième fonction utilise également un nom différent, args, pour le paramètre.
package {
	import flash.display.MovieClip;
	
	public class RestParamExample extends MovieClip {
		public function RestParamExample() {
			traceParams(100, 130, "two"); // 100,130,two
			trace(average(4, 7, 13));     // 8
		}
	}
}


function traceParams(... rest) {
 	trace(rest);
 }
 
function average(... args) : Number{
	var sum:Number = 0;
	for (var i:uint = 0; i < args.length; i++) {
		sum += args[i];
	}
	return (sum / args.length);
}

Eléments de l’API associés

AS3 Espaces de noms  

Définit des méthodes et propriétés des classes ActionScript essentielles correspondant à des propriétés fixes et non des propriétés de prototype. Lorsque vous définissez l’option « -as3 » du compilateur sur true (correspondant au paramètre par défaut dans Flex Builder 2), l’espace de noms AS3 est ouvert automatiquement pour toutes les classes essentielles. Par conséquent, les occurrences des classes essentielles utilisent des propriétés et méthodes fixes au lieu des versions de ces propriétés et méthodes qui sont liées à l’objet de prototype de la classe. L’utilisation de propriétés fixes permet généralement d’obtenir de meilleures performances, mais implique des problèmes de rétrocompatibilité avec la spécification de langage de la version 3 d’ECMAScript (ECMA-262).

Paramètres

Eléments de l’API associés

breakInstruction 
Utilisation

break [label]

Apparaît au sein d’une boucle (for, for..in, for each..in, do..while ou while) ou dans un bloc d’instructions associées à un cas précis dans une instruction switch. Lorsqu’elle est utilisée dans une boucle, l’instruction break indique au compilateur Flash d’ignorer le reste du corps de boucle, d’interrompre l’action de boucle et d’exécuter l’instruction suivant l’instruction de boucle. Lorsqu’elle est utilisée dans une instruction switch, l’instruction break indique au compilateur Flash d’ignorer le reste des instructions de ce bloc case et de sauter jusqu’à la première instruction suivant l’instruction switch encadrante.

Dans les boucles imbriquées, l’instruction break implique d’ignorer le reste de la boucle immédiate et n’interrompt pas toute la série de boucles imbriquées. Pour sortir d’une série de boucles imbriquées, utilisez label ou try...catch..finally.

L’instruction break peut comporter une étiquette facultative devant correspondre à une instruction externe avec étiquette. L’utilisation d’une étiquette ne correspondant à aucune étiquette d’instruction externe constitue une erreur de syntaxe. Les instructions break nommées permettent de sortir de plusieurs niveaux d’instructions de boucle imbriqués, ainsi que d’instructions switch ou block. Pour obtenir un exemple, voir l’entrée concernant l’instruction label.

Paramètres
label:* — Nom d’une étiquette associée à une instruction.

Exemple
Comment utiliser cet exemple
L’exemple suivant utilise break pour sortir d’une boucle autrement infinie :
var i:int = 0;
while (true) { 
	trace(i); 
	if (i >= 10) { 
		break; // this will terminate/exit the loop 
	} 
	i++; 
} 
/*
0 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10*/

Eléments de l’API associés

caseInstruction 
Utilisation

case jumpTarget: statements

Définit un hyperlien cible pour l’instruction switch. Si le paramètre jumpTarget est égal au paramètre expression de l’instruction switch avec une égalité stricte (===), Flash Player exécute les instructions du paramètre statements jusqu’à atteindre une instruction break ou la fin de l’instruction switch.

Si vous utilisez l’instruction case en dehors d’une instruction switch, elle provoque une erreur et le script n’est pas compilé.

Paramètres
jumpTarget:* — Toute expression.
statements:* — Instructions à exécuter si jumpTarget correspond à l’expression conditionnelle de l’instruction switch.

Exemple
Comment utiliser cet exemple
L’exemple suivant définit des cibles de saut pour l’instruction switch nommée thisMonth. Si l’instruction thisMonth est égale à l’expression de l’instruction case, alors elle est exécutée.
var thisMonth:int = new Date().getMonth(); 
switch (thisMonth) { 
	case 0 : 
		trace("January"); 
		break; 
	case 1 : 
		trace("February"); 
		break; 
	case 5 : 
	case 6 : 
	case 7 : 
		trace("Some summer month"); 
		break; 
	case 8 : 
		trace("September"); 
		break; 
	default : 
		trace("some other month"); 
}

Eléments de l’API associés

classMot-clé de la définition 
Utilisation

[dynamic] [public | internal] [final] class className [ extends superClass ] [ implements interfaceName[, interfaceName... ] ] { 
	// class definition here
}

Définit une classe, permettant d’instancier des objets ayant en commun des méthodes et propriétés personnalisées. Par exemple, si vous développez un système de suivi de facturation, vous pouvez créer une classe Invoice définissant toutes les méthodes et les propriétés destinées à l’ensemble des factures. Vous pouvez alors utiliser la commande new Invoice() pour créer des objets de classe Invoice.

Chaque fichier source ActionScript ne peut contenir qu’une seule classe visible aux autres scripts ou fichiers source. La classe visible en externe peut être publique ou interne et doit être définie dans une instruction de package. Si vous incluez d’autres classes dans le même fichier, elles doivent être placées en dehors de l’instruction de package et à la fin du fichier.

Le nom de la classe visible en externe doit correspondre au nom du fichier source ActionScript contenant la classe. Le nom du fichier source doit être le nom de la classe portant l’extension .as. Par exemple, si vous nommez une classe Student, le fichier définissant la classe doit porter le nom Student.as.

Les définitions de classe ne peuvent pas être imbriquées, vous ne pouvez donc pas définir des classes supplémentaires au sein d’une définition de classe.

Vous pouvez définir une méthode de constructeur, exécutée lors de chaque création d’une nouvelle instance de la classe. Le nom de la méthode de constructeur doit correspondre au nom de la classe. Si vous ne définissez aucune méthode de constructeur, un constructeur par défaut est créé automatiquement.

Pour indiquer que les objets peuvent ajouter ou consulter des propriétés dynamiques lors de l’exécution, faites précéder l’instruction de classe du mot-clé dynamic. Pour déclarer qu’une classe implémente une interface, utilisez le mot-clé implements. Pour créer des sous-classes d’une classe, utilisez le mot-clé extends (une classe ne peut étendre qu’une seule classe, mais peut implémenter plusieurs interfaces). Vous pouvez utiliser les mots-clés implements et extends dans une même instruction. Les exemples suivants illustrent des utilisations courantes des mots-clés implements et extends :

class C implements Interface_i, Interface_j // OK 
class C extends Class_d implements Interface_i, Interface_j // OK 
class C extends Class_d, Class_e // not OK 

Paramètres
className:Class — Nom entièrement qualifié de la classe.

Exemple
Comment utiliser cet exemple
L’exemple suivant crée une classe nommée Plant. Le constructeur Plant accepte deux paramètres.
// Filename Plant.as 
package {
  public class Plant { 
	// Define property names and types 
	private var _leafType:String; 
	private var _bloomSeason:String; 
	// Following line is constructor 
	// because it has the same name as the class 
	public function Plant(param_leafType:String, param_bloomSeason:String) { 
		// Assign passed values to properties when new Plant object is created 
		_leafType = param_leafType; 
		_bloomSeason = param_bloomSeason; 
	} 
	// Create methods to return property values, because best practice 
	// recommends against directly referencing a property of a class 
	public function get leafType():String { 
		return _leafType; 
	} 
	public function get bloomSeason():String { 
		return _bloomSeason; 
	} 
  }
}
Dans le script, utilisez l’opérateur new pour créer un objet Plant.
var pineTree:Plant = new Plant("Evergreen", "N/A"); 
// Confirm parameters were passed correctly 
trace(pineTree.leafType); 
trace(pineTree.bloomSeason); 

Eléments de l’API associés

constMot-clé de la définition 
Utilisation

const identifier = value 

Spécifie une constante, variable ne pouvant recevoir de valeur qu’une seule fois.

Vous pouvez définir le type d’une constante de façon stricte en lui ajoutant un caractère deux points (:) suivi du type de données.

Paramètres
identifier:* — Identificateur pour la constante.

Exemple
Comment utiliser cet exemple
L’exemple suivant montre qu’une erreur se produit lorsque vous tentez d’affecter plusieurs fois une valeur à une constante.
const MIN_AGE:int = 21;
MIN_AGE = 18; // error
L’exemple suivant montre que si une constante est un tableau, vous pouvez toujours appeler les méthodes de la classe Array, y compris Array.push(). Néanmoins, vous ne pouvez pas affecter un nouveau littéral de tableau.
const product_array:Array = new Array("Studio", "Dreamweaver", "Flash", "ColdFusion", "Contribute", "Breeze"); 
product_array.push("Flex"); // array operations are allowed
product_array = ["Other"];  // assignment is an error
trace(product_array); 

Eléments de l’API associés

continueInstruction 
Utilisation

continue [label]

Saute toutes les instructions restantes dans la boucle de plus bas niveau et commence la prochaine itération de la boucle, comme si le contrôle était passé normalement à la fin de la boucle. L’instruction continue n’a aucun effet en dehors d’une boucle. Dans les boucles imbriquées, utilisez le paramètre facultatif label pour ignorer plus que la boucle de plus bas niveau.

L’instruction continue peut comporter une étiquette facultative devant correspondre à une instruction externe avec étiquette. L’utilisation d’une étiquette ne correspondant à aucune étiquette d’instruction externe constitue une erreur de syntaxe. Les instructions continue nommées permettent de sauter plusieurs niveaux d’instructions de boucle imbriquées.

Paramètres

Exemple
Comment utiliser cet exemple
Dans la boucle while suivante, l’instruction continue est utilisée pour ignorer le reste du corps de boucle à chaque multiple de 3, puis sauter au début de la boucle pour revenir au test de la condition :
var i:int = 0; 
while (i < 10) { 
	if (i % 3 == 0) { 
		i++; 
		continue; 
	} 
	trace(i); 
	i++; 
}
Dans une boucle for, l’instruction continue permet également d’ignorer le reste du corps de boucle. Dans l’exemple suivant, dès que i % 3 est égal à 0, l’instruction trace(i) est ignorée :
 
for (var i:int = 0; i < 10; i++) { 
	if (i % 3 == 0) { 
		continue; 
	} 
	trace(i); 
}

Eléments de l’API associés

defaultInstruction 
Utilisation

default: statements 

Définit le cas par défaut pour une instruction switch. Les instructions sont exécutées si le paramètre expression de l’instruction switch n’est pas égal (avec l’opération d’égalité stricte [===]) à l’un des paramètres expression suivant les mots-clés case d’une instruction switch donnée.

Une instruction switch ne nécessite aucune instruction de cas default. Une instruction de cas default ne doit pas nécessairement figurer en fin de liste. Si vous utilisez une instruction default en-dehors d’une instruction switch, elle provoque une erreur et le script n’est pas compilé.

Paramètres
statements:* — Toutes instructions.

Exemple
Comment utiliser cet exemple
Dans l’exemple suivant, si le jour de la semaine est samedi ou dimanche, aucune des instructions case ne s’applique, l’exécution passe donc à l’instruction default.
var dayOfWeek:int = new Date().getDay(); 
switch (dayOfWeek) { 
	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; 
	default : 
		trace("Weekend"); 
}

Eléments de l’API associés

default xml namespace Directives  
Utilisation

default xml namespace = ns

La directive default xml namespace définit l’espace de noms par défaut à utiliser pour les objets XML.

Si vous ne définissez aucune directive default xml namespace, l’espace de noms par défaut est non nommé (avec l’URI définie sur une chaîne vide). L’étendue d’une déclaration default xml namespace est l’intérieur d’un bloc de fonction, comme l’étendue d’une variable.

Paramètres

Exemple
Comment utiliser cet exemple
L’exemple suivant montre que l’étendue de la directive default xml namespace est un bloc de fonction :
var nsDefault1:Namespace = new Namespace("http://www.example.com/namespaces/");
default xml namespace = nsDefault1;
	    
var x1:XML = ;
trace("x1 ns: " + x1.namespace());
			
scopeCheck();	

var x2:XML = ;
trace("x2 ns: " + x2.namespace());
		
function scopeCheck(): void {
	
	var x3:XML = ;
	trace("x3 ns: " + x3.namespace());
				
	var nsDefault2:Namespace = new Namespace("http://schemas.xmlsoap.org/soap/envelope/");
	default xml namespace = nsDefault2;
		    
	var x4:XML = ;
	trace("x4 ns: " + x4.namespace());

}
La sortie trace() de cet exemple est la suivante : x1 ns: http://www.example.com/namespaces/ x3 ns: x4 ns: http://schemas.xmlsoap.org/soap/envelope/ x2 ns: http://www.example.com/namespaces/ L’exemple suivant utilise la directive default xml namespace pour affecter l’espace de noms par défaut. Le second objet XML (x2) n’utilise pas ce paramètre, car x2 définit son propre espace de noms :
var nsDefault:Namespace = new Namespace("http://www.example.com/namespaces/");
default xml namespace = nsDefault;
            
var x1:XML = ;

trace(x1.namespace());
	// http://www.example.com/namespaces/

var x2:XML = ;
trace(x2.namespace());
	// http://www.w3.org/1999/XSL/Transform/

var x3:XML = ;
trace(x3.namespace());
	// http://www.example.com/namespaces/

Eléments de l’API associés

do..whileInstruction 
Utilisation

do { statement(s) } while (condition)

Similaire à une boucle while, sauf que les instructions sont exécutées une fois avant l’évaluation initiale de la condition. Par la suite, les instructions sont exécutées uniquement si la condition est évaluée à true.

La boucle do..while permet de s’assurer que le code de la boucle s’exécute au moins une fois. Bien que cela puisse également se faire avec une boucle while en plaçant une copie des instructions à exécuter avant le début de la boucle while, de nombreux programmeurs trouvent les boucles do..while plus faciles à lire.

Si la condition renvoie toujours true, la boucle do..while est infinie. Si vous entrez dans une boucle infinie, vous rencontrez des problèmes avec Flash Player, puis un message d’erreur s’affiche ou le lecteur se bloque. Autant que possible, utilisez une boucle for si vous connaissez le nombre d’itérations souhaitées. Bien que les boucles for soient plus faciles à lire et déboguer, elles ne sont pas totalement interchangeables avec les boucles do..while.

Paramètres
condition:Boolean — La condition à évaluer. Les instructions au sein du bloc de code do sont exécutées tant que le paramètre condition est évalué à true.

Exemple
Comment utiliser cet exemple
L’exemple suivant utilise une boucle do..while afin de déterminer si une condition a la valeur true et suit myVar jusqu’à ce que la valeur de myVar soit supérieure ou égale à 5. Lorsque la valeur myVar est supérieure ou égale à 5, la boucle se termine.
var myVar:Number = 0; 
do { 
	trace(myVar); 
	myVar++; 
} 
while (myVar < 5); 
/*
0 
1 
2 
3 
4
*/

Eléments de l’API associés

dynamicMot-clé de l’attribut 
Utilisation

dynamic class className { // class definition here }

Spécifie que les instances d’une classe peuvent disposer de propriétés dynamiques ajoutées lors de l’exécution. Si vous utilisez l’attribut dynamic sur une classe, vous pouvez ajouter des propriétés à des occurrences de cette classe lors de l’exécution. Les classes non marquées avec l’attribut dynamic sont considérées scellées, ce qui signifie qu’aucune propriété ne peut être ajoutée aux occurrences de la classe.

Si une classe est scellée (non dynamique), les tentatives de lecture ou de définition de propriétés sur les instances de classe provoquent une erreur. Si le compilateur est défini en mode strict et si vous spécifiez le type de données lors de la création d’occurrences, les tentatives d’ajout de propriétés à des objets scellés génèrent une erreur de compilateur ; sinon, il s’agit d’une erreur du moteur d’exécution.

L’attribut dynamic n’est pas hérité par les sous-classes. Si vous étendez une classe dynamique, la sous-classe n’est dynamique que si vous la déclarez avec l’attribut dynamic.

Paramètres

Exemple
Comment utiliser cet exemple
L’exemple suivant crée deux classes : une classe dynamique nommée Expando et une classe scellée nommée Sealed, utilisées dans les exemples ultérieurs.
package {

	dynamic class Expando  {
	}
	
	class Sealed {
	}
}
Le code suivant crée une occurrence de la classe Expando et montre qu’il est possible d’ajouter des propriétés à l’occurrence.
var myExpando:Expando = new Expando();
myExpando.prop1 = "new";
trace(myExpando.prop1); // new
Le code suivant crée une occurrence de la classe Sealed et montre qu’une tentative d’ajouter une propriété provoque une erreur.
var mySealed:Sealed = new Sealed();
mySealed.prop1 = "newer"; // error

Eléments de l’API associés

elseInstruction 
Utilisation

if (condition) { 
	// statement(s)
} 
else {
	// statement(s)
}

Spécifie les instructions à exécuter si la condition de l’instruction if retourne la valeur false. Les accolades ({}) encadrant les instructions à exécuter par l’instruction else sont inutiles s’il ne s’agit que d’une seule instruction.

Paramètres
condition:Boolean — Une expression dont la valeur est évaluée à true ou false.

Exemple
Comment utiliser cet exemple
Dans l’exemple suivant, la condition else permet de vérifier si la variable age_txt est supérieure ou inférieure à 18 :
if (age_txt.text>=18) { 
	trace("welcome, user"); 
} 
else { 
	trace("sorry, junior"); 
	userObject.minor = true; 
	userObject.accessAllowed = false;
}
Dans l’exemple suivant, les accolades ({}) ne sont pas nécessaires car une seule instruction figure après l’instruction else :
if (age_txt.text>18) { 
	trace("welcome, user");
} 
else trace("sorry, junior");
L’exemple suivant utilise une combinaison des instructions if et else pour comparer la variable score_txt à une valeur spécifiée :
if (score_txt.text>90) { 
	trace("A"); 
} 
else if (score_txt.text>75) { 
	trace("B"); 
} 
else if (score_txt.text>60) { 
	trace("C"); 
} 
else { 
	trace("F"); 
}

Eléments de l’API associés

extendsMot-clé de la définition 
Utilisation

class className extends otherClassName {}
interface interfaceName extends otherInterfaceName {} 

Définit une classe correspondant à une sous-classe d’une autre classe. La sous-classe hérite de l’ensemble des méthodes, propriétés, fonctions, etc. définies dans la superclasse. Les classes marquées avec l’attribut final ne peuvent pas être étendues.

Vous pouvez également utiliser le mot-clé extends pour étendre une interface. Une interface qui en étend une autre inclut l’ensemble des déclarations de méthode de l’interface d’origine.

Paramètres
className:Class — Le nom de la classe en cours de définition.

Exemple
Comment utiliser cet exemple
Dans l’exemple suivant, la classe Car étend la classe Vehicle de manière à hériter toutes ses méthodes, propriétés et fonctions. Si le script instancie un objet Car, vous pouvez utiliser les méthodes des deux classes Car et Vehicle à la fois. L’exemple suivant illustre le contenu d’un fichier nommé Vehicle.as, définissant la classe Vehicle :
package {
	class Vehicle { 
	    var numDoors:Number; 
	    var color:String; 
	    public function Vehicle(param_numDoors:Number = 2, param_color:String = null) { 
	        numDoors = param_numDoors; 
	        color = param_color; 
	    } 
	    public function start():void { 
	        trace("[Vehicle] start"); 
	    } 
	    public function stop():void { 
	        trace("[Vehicle] stop"); 
	    } 
	    public function reverse():void { 
	        trace("[Vehicle] reverse"); 
	    } 
	}	
}
L’exemple suivant montre un deuxième fichier ActionScript, nommé Car.as, dans le même répertoire. Cette classe étend la classe Vehicle en la modifiant de trois manières. Premièrement, la classe Car ajoute une variable fullSizeSpare permettant de suivre si l’objet voiture dispose d’une roue de secours de taille normale. Deuxièmement, elle ajoute une nouvelle méthode activateCarAlarm() spécifique aux voitures, permettant d’activer leur alarme antivol. Troisièmement, elle remplace la fonction stop() pour ajouter le fait que la classe Car utilise un système de freinage anti-blocage des roues pour s’arrêter.
package {

	public class Car extends Vehicle { 
	    var fullSizeSpare:Boolean; 
	    public function Car(param_numDoors:Number, param_color:String, param_fullSizeSpare:Boolean) { 
	        numDoors = param_numDoors; 
	        color = param_color; 
	        fullSizeSpare = param_fullSizeSpare; 
	    } 
	    public function activateCarAlarm():void { 
	        trace("[Car] activateCarAlarm"); 
	    } 
	    public override function stop():void { 
	        trace("[Car] stop with antilock brakes"); 
	    } 
	}
}
L’exemple suivant instancie un objet Car, puis appelle une méthode définie dans la classe Vehicle (start()), une méthode remplacée par la classe Car (stop()) et enfin une méthode de la classe Car (activateCarAlarm()) :
var myNewCar:Car = new Car(2, "Red", true); 
myNewCar.start(); // [Vehicle] start 
myNewCar.stop(); // [Car] stop with anti-lock brakes 
myNewCar.activateCarAlarm(); // [Car] activateCarAlarm
Vous pouvez également écrire une sous-classe de la classe Vehicle à l’aide de l’instruction super, permettant à la sous-classe d’accéder au constructeur de la superclasse. L’exemple suivant montre un troisième fichier ActionScript, nommé Truck.as, toujours dans le même répertoire. La classe Truck utilise l’instruction super dans le constructeur et dans la méthode reverse() remplacée.
package {
	class Truck extends Vehicle {
		var numWheels:Number;
		public function Truck(param_numDoors:Number, param_color:String, param_numWheels:Number) { 
			super(param_numDoors, param_color); 
			numWheels = param_numWheels; 
		} 
		public override function reverse():void { 
			beep();
			super.reverse();
		} 
		public function beep():void { 
			trace("[Truck] make beeping sound"); 
		} 
	}
}
L’exemple suivant instancie un objet Truck, appelle une méthode remplacée par la classe Truck (reverse()), puis appelle une méthode de la classe Vehicle (stop()) :
var myTruck:Truck = new Truck(2, "White", 18); 
myTruck.reverse(); // [Truck] make beeping sound [Vehicle] reverse 
myTruck.stop(); // [Vehicle] stop

Eléments de l’API associés

falseMot-clé de l’expression principale 
Utilisation

false

Valeur booléenne false. Une valeur booléenne est soit true soit false. L’opposé de false est true.

Lorsque l’affectation automatique de données à un type convertit false en nombre, la valeur devient 0. Lorsqu’elle convertit false en chaîne, elle retourne "false".

Remarque : la chaîne "false" est convertie en valeur booléenne true.

Paramètres

Exemple
Comment utiliser cet exemple
Cet exemple indique la manière dont la saisie automatique des données convertit false en nombre et en chaîne :
var bool1:Boolean = Boolean(false);

// converts it to the number 0
trace(1 + bool1); // outputs 1

// converts it to a string
trace("String: " + bool1); // outputs String: false
L’exemple suivant montre que la chaîne "false" est convertie en valeur booléenne true :
trace(Boolean("false")); // true

if ("false") {
	trace("condition expression evaluated to true");
}
else {
	trace("condition expression evaluated to false");
}
// condition expression evaluated to true

Eléments de l’API associés

finalMot-clé de l’attribut 
Utilisation

final function methodName() { 
	// your statements here 
}
final class className {}

Spécifie qu’une méthode ne peut pas être remplacée ou qu’une classe ne peut pas être étendue. Toute tentative de remplacer une méthode, ou d’étendre une classe, marquée avec l’attribut final génère une erreur.

Paramètres
methodName:Function — Nom de la méthode ne pouvant pas être remplacée.
className:Class — Nom de la classe ne pouvant pas être étendue.

Eléments de l’API associés

flash_proxy Espaces de noms  

Définit les méthodes de la classe Proxy. Les méthodes de la classe Proxy figurent dans leur propre espace de noms afin d’éviter les conflits de noms lorsqu’une sous-classe Proxy contient des noms de méthode d’occurrence identiques aux noms des méthodes de classe Proxy.

Paramètres

Eléments de l’API associés

forInstruction 
Utilisation

for ([init]; [condition]; [next]) { 
	// statement(s)
}

Evalue l’expression init (initialisation) une fois, puis commence une séquence de boucle. La séquence de boucle commence par l’évaluation de l’expression condition. Si l’expression condition est évaluée à true, l’instruction statement est exécutée et l’expression next est évaluée. La séquence de boucle recommence alors avec l’évaluation de l’expression condition.

Les accolades ({}) encadrant le bloc d’instructions à exécuter par l’instruction for sont inutiles s’il ne s’agit que d’une seule instruction.

Paramètres
init — Expression facultative à évaluer avant de commencer la séquence de boucle ; habituellement il s’agit d’une expression d’affectation. Une instruction var est également autorisée pour ce paramètre.
condition — Expression facultative à évaluer avant de commencer la séquence de boucle ; habituellement il s’agit d’une expression de comparaison. Si l’expression est évaluée à true, les instructions associées avec l’instruction for sont exécutées.
next — Expression facultative à évaluer après la séquence de boucle ; habituellement il s’agit d’une expression d’incrémentation ou de décrémentation.

Exemple
Comment utiliser cet exemple
L’exemple suivant utilise une boucle for pour ajouter les éléments d’un tableau :
var my_array:Array = new Array(); 
for (var i:Number = 0; i < 10; i++) { 
	my_array[i] = (i + 5) * 10;  
} 
trace(my_array); // 50,60,70,80,90,100,110,120,130,140 
L’exemple suivant utilise une boucle for pour effectuer une même action plusieurs fois. Dans le code, la boucle for ajoute les nombres de 1 à 100.
var sum:Number = 0; 
for (var i:Number = 1; i <= 100; i++) { 
	sum += i; 
} 
trace(sum); // 5050
L’exemple suivant montre que les accolades ({}) sont inutiles si une seule instruction est exécutée :
var sum:Number = 0; 
for (var i:Number = 1; i <= 100; i++) 
	sum += i; 
trace(sum); // 5050

Eléments de l’API associés

for..inInstruction 
Utilisation

for (variableIterant:String in object){ 
	// statement(s)
} 

Effectue une itération pour chaque propriété dynamique d’un objet ou chaque élément d’un tableau et exécute l’instruction statement pour chaque propriété ou élément. Les propriétés d’objet sont conservées sans ordre particulier, elles peuvent donc apparaître dans un ordre apparemment aléatoire. Les propriétés fixes, telles que les variables et les méthodes définies dans une classe, ne sont pas énumérées par l’instruction for...in. Pour obtenir une liste de propriétés fixes, utilisez la fonction describeType() figurant dans le package flash.utils.

Paramètres
variableIterant:String — Nom d’une variable à utiliser en tant qu’itéré, référençant chaque propriété d’un objet ou chaque élément d’un tableau.

Exemple
Comment utiliser cet exemple
L’exemple suivant utilise for..in pour effectuer une itération sur les propriétés d’un objet :
var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for (var prop in myObject) { 
	trace("myObject."+prop+" = "+myObject[prop]); 
} 
/*
myObject.firstName = Tara 
myObject.age = 27 
myObject.city = San Francisco
*/
L’exemple suivant utilise l’opérateur typeof conjointement avec for..in pour effectuer une itération sur un type d’enfant particulier :
var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for (var name in myObject) { 
	if (typeof (myObject[name]) == "string") { 
		trace("I have a string property named "+name); 
	} 
}
/*
I have a string property named city
I have a string property named firstName
*/

Plus d’exemples

Eléments de l’API associés

for each..inInstruction 
Utilisation

for each (variableIterant in object){ 
	// statement(s)
} 

Effectue une itération pour chaque élément d’une collection et exécute l’instruction statement pour chaque élément. Présentée dans le cadre des extensions de langage E4X, l’instruction for each..in peut être utilisée non seulement pour les objets XML, mais également pour les objets et les tableaux. L’instruction for each....in procède à une itération uniquement pour les propriétés dynamiques d’un objet et non pas pour les propriétés fixes. Une propriété fixe est une propriété définie comme partie d’une définition de classe. Pour utiliser l’instruction for each..in avec une occurrence de classe définie par l’utilisateur, vous devez déclarer cette classe avec l’attribut dynamic.

Contrairement à l’instruction for...in, l’instruction for each..in procède à des itérations sur les valeurs des propriétés d’un objet et non pas sur les noms de propriétés.

Paramètres
variableIterant:* — Nom d’une variable jouant le rôle d’itéré, référençant l’élément dans une collection.
object:Object — Nom d’une collection à parcourir par itérations. La collection peut correspondre à un objet XML, un objet générique ou un tableau.

Exemple
Comment utiliser cet exemple
L’exemple suivant utilise l’instruction for each..in pour procéder à une itération sur les valeurs des propriétés d’un objet :
var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for each (var item in myObject) { 
	trace(item); 
} 
/*
Tara
27
San Francisco
*/
L’exemple suivant utilise l’instruction for each..in pour effectuer une itération sur les éléments d’un tableau :
var myArray:Array = new Array("one", "two", "three"); 
for each(var item in myArray) 
	trace(item); 
/*
one
two
three
*/
L’exemple suivant utilise l’opérateur is avec l’instruction for each..in pour effectuer une itération sur un type d’enfant particulier :
var myObject:Object = {firstName:"Tara", age:27, city:"San Francisco"}; 
for each (var item in myObject) { 
	if (item is String) {  
		trace("I have a string property with value " + item); 
	} 
}

/*
I have a string property with value Tara
I have a string property with value San Francisco
*/
L’exemple suivant explique comment utiliser une instruction for each..in pour procéder à une itération sur les propriétés d’un objet XMLList (doc.p) :
var doc:XML = 
		
			

Hello

Hola


Bonjour

; for each (var item in doc.p) { trace(item); } /* Hello Hola Bonjour */

Plus d’exemples

functionMot-clé de la définition 
Utilisation

function functionName([parameter0, parameter1,...parameterN]) : returnType{ 
	// statement(s) 
} 
var functionName:Function = function ([parameter0, parameter1,...parameterN]) : returnType{ 
	// statement(s) 
} 

Comprend un ensemble d’instructions définies pour l’exécution d’une tâche particulière. Vous pouvez définir une fonction à un emplacement, puis l’invoquer ou l’appeler depuis différents scripts dans un fichier SWF. Lors de la définition d’une fonction, vous pouvez également spécifier ses paramètres. Les paramètres sont des emplacements fictifs pour les valeurs utilisées par la fonction. Vous pouvez transmettre à une fonction des paramètres différents à chaque appel, afin de la réutiliser dans différentes situations.

Utilisez l’instruction return dans le bloc d’instructions statement(s) pour faire générer ou retourner une valeur par une fonction.

Utilisation 1 : vous pouvez utiliser le mot-clé function pour définir une fonction avec le nom, les paramètres et les instructions requis. Lorsqu’un script appelle une fonction, les instructions comprises dans la définition de la fonction sont exécutées. Les références par anticipation sont autorisées ; au sein d’un même script, une fonction peut être déclarée après son appel. Une définition de fonction remplace toute définition antérieure de la même fonction. Vous pouvez utiliser cette syntaxe à tout emplacement permettant l’utilisation d’une instruction.

Utilisation 2 : vous pouvez également utiliser function pour créer une fonction anonyme et lui renvoyer une référence. Cette syntaxe est utilisée dans les expressions ; elle est particulièrement utile pour l’installation de méthodes dans les objets.

Pour plus de fonctionnalité, vous pouvez utiliser l’objet arguments dans la définition de fonction. L’objet arguments est couramment utilisé pour créer une fonction acceptant un nombre de paramètres variable et pour créer une fonction anonyme récursive.

Paramètres
functionName:Function — Nom de la nouvelle fonction.
returnType:* — Type de données de la valeur renvoyée.

Exemple
Comment utiliser cet exemple
L’exemple suivant définit la fonction sqr, qui retourne le carré de la valeur d’un nombre :
function sqr(xNum:Number) { 
	return Math.pow(xNum, 2); 
} 
var yNum:Number = sqr(3); 
trace(yNum); // 9
Si la fonction est définie et utilisée dans le même script, sa définition peut figurer après son utilisation :
var yNum:Number = sqr(3); 
trace(yNum); // 9 
function sqr(xNum:Number) { 
	return Math.pow(xNum, 2); 
}

Eléments de l’API associés

getMot-clé de la définition 
Utilisation

function get property() : returnType{ 
	// your statements here 
}

Définit une méthode getter qui peut être lue comme une propriété. Un getter est une fonction spéciale qui retourne la valeur d’une propriété déclarée avec le mot-clé var ou const. Contrairement aux autres méthodes, un getter est appelé sans parenthèses (()), ce qui le fait ressembler à une variable.

Les méthodes getter permettent d’appliquer le principe de masquage des informations par la création d’une interface publique pour une propriété privée. L’avantage du masquage des informations est que l’interface publique reste identique même si l’implémentation sous-jacente de la propriété privée change.

Les méthodes getter présentent également l’avantage de pouvoir être remplacées dans des sous-classes, contrairement aux propriétés déclarées avec var ou const.

Un getter peut être combiné avec un setter pour former une propriété en lecture/écriture. Pour créer une propriété en lecture seule, créez un getter sans setter correspondant. Pour créer une propriété en écriture seule, créez un setter sans getter correspondant.

Paramètres
property:* — L’identificateur de la propriété à laquelle get accède. Cette valeur doit correspondre à la valeur utilisée dans la commande set correspondante.
returnType:* — Type de données de la valeur renvoyée.

Exemple
Comment utiliser cet exemple
L’exemple suivant définit une classe Team. La classe Team inclut les méthodes getter et setter qui permettent de récupérer et de définir des propriétés au sein de la classe :
package {
	public class Team { 
		var teamName:String; 
		var teamCode:String; 
		var teamPlayers:Array = new Array(); 
		public function Team(param_name:String, param_code:String) { 
			teamName = param_name; 
			teamCode = param_code; 
		} 
		public function get name():String { 
			return teamName; 
		} 
		public function set name(param_name:String):void { 
			teamName = param_name; 
		}
	} 
}
Entrez le code suivant dans le script :
var giants:Team = new Team("San Fran", "SFO"); 
trace(giants.name); 
giants.name = "San Francisco"; 
trace(giants.name); 
/*
San Fran San Francisco */
Lorsque vous surveillez giants.name, vous utilisez une méthode getter pour retourner la valeur de cette propriété.

Eléments de l’API associés

ifInstruction 
Utilisation

if (condition) {
	// statement(s)
}

Evalue une condition pour déterminer la prochaine instruction à exécuter. Lorsque cette condition a la valeur true, Flash Player exécute les instructions qui suivent la condition entre accolades ({}). Si la condition a la valeur false, Flash Player ignore les instructions entre accolades et exécute les instructions qui suivent ces accolades. Utilisez l’instruction if avec l’instruction else pour mettre en place une logique conditionnelle dans les scripts.

Les accolades ({}) encadrant les instructions à exécuter par l’instruction if sont facultatives s’il ne s’agit que d’une seule instruction.

Paramètres
condition:Boolean — Une expression dont la valeur est évaluée à true ou false.

Eléments de l’API associés

implementsMot-clé de la définition 
Utilisation

myClass implements interface01 [, interface02 , ...] 

Spécifie qu’une classe implémente une ou plusieurs interfaces. Lorsqu’une classe implémente une interface, la classe doit définir toutes les méthodes qui y sont déclarées. Toute occurrence d’une classe qui implémente une interface est considérée comme un membre du type de données défini par l’interface. Par conséquent, l’opérateur is retourne true lorsque l’occurrence de classe correspond au premier opérande et l’interface au deuxième. En outre, les coercitions de type depuis et vers le type de données défini par l’interface fonctionnent.

Paramètres

Eléments de l’API associés

import Directives  
Utilisation

import packageName.className 
import packageName.*

Rend les classes et les packages définis en externe disponibles pour le code. Par exemple, vous devez importer la classe flash.display.Sprite avant de pouvoir l’utiliser dans un script. Cette condition diffère des versions précédentes d’ActionScript, pour lesquelles la directive import était facultative.

Après avoir utilisé la directive import, vous pouvez utiliser le nom de classe complet, qui comprend le nom du package, ou simplement le nom de la classe.

 
import flash.display.Sprite; 

// name of class only
var mySprite:Sprite = new Sprite();

// full class name
var mySprite:flash.display.Sprite = new flash.display.Sprite();

Si le package contient plusieurs classes auxquelles vous souhaitez accéder, vous pouvez les importer toutes avec une même instruction, comme dans l’exemple suivant :

import flash.display.*;

La directive import importe uniquement les classes, les fonctions et les variables résidant au niveau supérieur du package importé. Les packages imbriqués doivent être importés de façon explicite.

Si vous importez une classe sans l’utiliser dans le script, elle n’est pas exportée avec le fichier SWF. Cela signifie que vous pouvez importer des packages volumineux sans vous préoccuper de la taille du fichier SWF. Le code en octets associé à une classe n’est inclus dans un fichier SWF que si la classe est véritablement utilisée. L’un des inconvénients de l’importation de classes superflues est l’augmentation des risques de confusion de noms.

// On Frame 1 of a FLA: 
import adobe.example.*; 
var myFoo:foo = new foo();

Paramètres
packageName:* — Nom d’un package que vous avez défini dans un fichier de classe distinct.
className:Class — Nom d’une classe que vous avez définie dans un fichier de classe distinct.
include Directives  
Utilisation

include "[path]filename.as"

Comprend le contenu du fichier spécifié, comme si les commandes du fichier faisaient partie du script d’appel. La directive include est invoquée lors de la compilation. Par conséquent, si vous apportez des modifications à un fichier inclus, vous devez l’enregistrer puis recompiler tous les fichiers SWF éventuels qui l’utilisent.

Paramètres
interfaceMot-clé de la définition 
Utilisation

 interface InterfaceName [extends InterfaceName ] {}

Définit une interface. Les interfaces sont des types de données qui définissent un ensemble de méthodes. Les méthodes doivent être définies par toute classe qui implémente l’interface.

Une interface est similaire à une classe, mais présente essentiellement les différences suivantes :

  • Les interfaces contiennent uniquement des déclarations de méthodes, pas leur implémentation. Ainsi, toute classe qui implémente une interface doit fournir une implémentation pour chaque méthode déclarée dans l’interface.
  • Les définitions de méthode d’interface ne peuvent pas avoir d’attributs tels que public ou private, mais les méthodes implémentées doivent être marquées comme public dans la définition de la classe qui implémente l’interface.
  • Plusieurs interfaces peuvent être héritées par une interface à l’aide de l’instruction extends ou par une classe à l’aide de l’instruction implements.

Contrairement à ActionScript 2.0, ActionScript 3.0 permet l’utilisation des méthodes getter et setter dans les définitions d’interface.

Paramètres

Eléments de l’API associés

internalMot-clé de l’attribut 
Utilisation

[internal] var varName
[internal] const kName
[internal] function functionName()  { 
	// your statements here 
}
[internal] class className{
	// your statements here 
}
[internal] namespace nsName

Spécifie qu’une classe, une variable, une constante ou une fonction est disponible pour tout appelant au sein du même package. Les classes, propriétés et méthodes appartiennent par défaut à l’espace de noms internal.

Paramètres
className:Class — Nom de la classe à spécifier en tant qu’interne.
varName:* — Nom de la variable à spécifier en tant qu’interne. Vous pouvez appliquer l’attribut internal, que la variable fasse partie d’une classe ou non.
kName:* — Nom de la constante à spécifier en tant qu’interne. Vous pouvez appliquer l’attribut internal, que la constante fasse partie d’une classe ou non.
functionName:Function — Nom de la fonction ou méthode à spécifier en tant qu’interne. Vous pouvez appliquer l’attribut internal, que la fonction fasse partie d’une classe ou non.
nsName:Namespace — Nom de l’espace de noms à spécifier en tant qu’interne. Vous pouvez appliquer l’attribut internal, que l’espace de noms fasse partie d’une classe ou non.

Eléments de l’API associés

labelInstruction 
Utilisation

label: statement
label: {
    statements
}

Associe une instruction à un identificateur pouvant être référencé par break ou continue. Dans les boucles imbriquées, une instruction break ou continue qui ne référence aucune étiquette peut ignorer uniquement le reste de la boucle en cours et n’ignore pas la série entière de boucles. Toutefois, si l’instruction qui définit toute la série de boucles dispose d’une étiquette associée, une instruction break ou continue peut ignorer la série entière de boucles en référençant cette étiquette.

Les étiquettes permettent également de s’échapper d’une instruction de bloc. Vous ne pouvez pas placer une instruction break sans référence à une étiquette dans une instruction de bloc, sauf si cette dernière fait partie d’une boucle. Si l’instruction de bloc dispose d’une étiquette associée, vous pouvez placer une instruction break faisant référence à cette étiquette dans l’instruction de bloc.

Paramètres
label:* — Un identificateur valide à associer à une instruction.
statements:* — Instruction à associer à l’étiquette.

Exemple
Comment utiliser cet exemple
L’exemple suivant indique comment utiliser une étiquette avec une boucle imbriquée pour sortir de la série entière de boucles. Le code utilise une boucle imbriquée pour générer une liste de nombres de 0 à 99. L’instruction break intervient juste avant que le décompte atteigne la valeur 80. Si l’instruction break n’avait pas utilisé l’étiquette outerLoop, le code ignorerait uniquement le reste de la boucle concernée et continuerait à générer les numéros 90 à 99. Toutefois, puisque l’étiquette outerLoop est utilisée, l’instruction break ignore le reste de la série entière de boucles et le dernier numéro généré est 79.
outerLoop: for (var i:int = 0; i < 10; i++) {
	for (var j:int = 0; j < 10; j++) {
		if ( (i == 8) && (j == 0)) {
			break outerLoop;
		}
		trace(10 * i + j);
	}
}
/*
1
2
...
79
*/
L’exemple suivant illustre l’utilisation d’une étiquette dans une instruction de bloc. Dans l’exemple suivant, une instruction de bloc porte l’étiquette foo, ce qui permet à l’instruction break d’ignorer la dernière instruction du bloc :
foo: {
	trace("a");
	break foo;
	trace("b");
}
// a

Eléments de l’API associés

namespaceMot-clé de la définition 
Utilisation

namespace name [= uri]

Permet de contrôler la visibilité des définitions. Les espaces de noms prédéfinis comportent public, private, protected et internal.

La procédure suivante indique comment créer, appliquer et référencer un espace de noms :

  • Tout d’abord, définissez l’espace de noms personnalisé à l’aide du mot-clé namespace. Par exemple, le code namespace version1 crée un espace de noms appelé version1.
  • Ensuite, appliquez l’espace de noms à une propriété ou une méthode en utilisant l’espace de noms personnalisé dans la déclaration de propriété ou de méthode. Par exemple, le code version1 myProperty:String crée une propriété appelée myProperty appartenant à l’espace de noms version1.
  • Enfin, référencez l’espace de noms à l’aide du mot-clé use ou en utilisant l’espace de noms en tant que préfixe d’identificateur. Par exemple, le code use namespace version1; référence l’espace de noms version1 pour les lignes de code suivantes et le code version1::myProperty référence l’espace de noms version1 pour la propriété myProperty.

Paramètres
name:Namespace — Nom de l’espace de noms, qui peut correspondre à tout identificateur légal.
uri:String — URI (Uniform Resource Identifier) de l’espace de noms. Ce paramètre est facultatif.

Eléments de l’API associés

nativeMot-clé de l’attribut 
Utilisation

native function functionName();
class className { 
	native function methodName();
}

Permet de spécifier si une fonction ou une méthode doit être implémentée par Flash Player en code natif. Flash Player utilise le mot-clé native en interne pour déclarer des fonctions et des méthodes dans l’interface de programmation d’application (API) d’ActionScript. Ce mot-clé ne peut pas être utilisé dans votre propre code.  

Paramètres
nullMot-clé de l’expression principale 
Utilisation

null

Une valeur spéciale qui peut être affectée aux variables ou renvoyée par une fonction en l’absence de données. Vous pouvez utiliser null pour représenter les valeurs manquantes ou dont le type de données n’est pas défini.

La valeur null ne doit pas être confondue avec la valeur spéciale undefined. Lorsque les propriétés null et undefined sont comparées avec l’opérateur d’égalité (==), elles sont considérées comme égales. Lorsque les propriétés null et undefined sont comparées avec l’opérateur d’égalité stricte (===), elles sont considérées comme différentes.

Paramètres

Exemple
Comment utiliser cet exemple
L’exemple suivant vérifie les six premières valeurs d’un tableau indexé et retourne un message si aucune valeur n’est définie (si value == null) :
var testArray:Array = new Array();
testArray[0] = "fee";
testArray[1] = "fi";
testArray[4] = "foo";

for (i = 0; i < 6; i++) {
    if (testArray[i] == null) {
        trace("testArray[" + i + "] == null");
    }
}

/* 
testArray[2] == null
testArray[3] == null
testArray[5] == null
*/

Eléments de l’API associés

object_proxy Espaces de noms  

Définit les méthodes de la classe ObjectProxy. Les méthodes de la classe ObjectProxy figurent dans leur propre espace de noms afin d’éviter les conflits de noms lorsqu’une sous-classe Proxy contient des noms de méthode d’occurrence identiques aux noms des méthodes de classe Proxy.

Paramètres
overrideMot-clé de l’attribut 
Utilisation

override function name() { 
	// your statements here 
}

Spécifie qu’une méthode remplace une méthode héritée. Pour remplacer une méthode héritée, vous devez utiliser l’attribut override et vous assurer que le nom, l’attribut de propriété de la classe, le nombre et le type des paramètres, ainsi que le type de retour concordent exactement. Toute tentative de remplacement d’une méthode sans l’attribut override constitue une erreur. De même, le fait d’utiliser l’attribut override lorsque la méthode ne dispose d’aucune méthode héritée correspondante constitue une erreur.

Vous ne pouvez pas utiliser l’attribut override avec les éléments suivants :

  • Variables
  • Constantes
  • Méthodes statiques
  • Méthodes non héritées
  • Méthodes implémentant une méthode d’interface
  • Méthodes héritées marquées avec l’attribut final dans la superclasse

Vous ne pouvez pas remplacer une propriété déclarée avec var ou const, mais vous pouvez obtenir une fonctionnalité similaire en transformant la propriété de la classe de base en getter/setter et en remplaçant les méthodes définies avec get et set.

Paramètres
name:Function — Nom de la méthode à remplacer.

Eléments de l’API associés

packageMot-clé de la définition 
Utilisation

package packageName {
    class someClassName { 
    } 
}

Permet d’organiser le code en groupes distincts pouvant être importés par d’autres scripts. Vous devez utiliser le mot-clé package pour indiquer si une classe appartient à un package.

Paramètres
packageName:* — Nom du package.

Eléments de l’API associés

privateMot-clé de l’attribut 
Utilisation

class className{ 
	private var varName;
	private const kName;
	private function methodName() { 
		// your statements here 
	}
	private namespace nsName;
}

Spécifie qu’une variable, une constante ou une méthode est disponible uniquement pour la classe qui la déclare ou la définit. Contrairement à ActionScript 2.0, dans ActionScript 3.0 private ne permet plus d’accéder aux sous-classes. De plus, private limite l’accès lors de la compilation et de l’exécution. Par défaut, une variable ou une fonction est disponible pour tout appelant dans le même package. Utilisez ce mot-clé pour restreindre l’accès à une variable ou une fonction.

Ce mot-clé peut être utilisé uniquement dans les définitions de classe, pas dans les définitions d’interface. Vous ne pouvez pas appliquer private à une classe ou toute autre définition au niveau du package.

Paramètres
varName:* — Nom de la variable à spécifier en tant que privée. Vous pouvez appliquer l’attribut private uniquement si la variable est à l’intérieur d’une classe.
kName:* — Nom de la constante à spécifier en tant que privée. Vous pouvez appliquer l’attribut private uniquement si la constante est à l’intérieur d’une classe.
methodName:Function — Nom de la méthode à spécifier en tant que privée. Vous pouvez appliquer l’attribut private uniquement si la méthode est à l’intérieur d’une classe.
nsName:Namespace — Nom de l’espace de noms à spécifier en tant que privé. Vous pouvez appliquer l’attribut private uniquement si l’espace de noms est à l’intérieur d’une classe.

Exemple
Comment utiliser cet exemple
L’exemple suivant démontre comment masquer certaines propriétés au sein d’une classe à l’aide du mot-clé private.
class A { 
  private var alpha:String = "visible only inside class A"; 
  public var beta:String = "visible everywhere"; 
}
	
class B extends A {
  function B() {
    alpha = "Access attempt from subclass"; // error
  }
}
Puisque alpha est une variable privée, vous ne pouvez pas y accéder en dehors de la classe A, ni même depuis la sous-classe B. Toute tentative d’accès à la variable privée génère une erreur.

Eléments de l’API associés

protectedMot-clé de l’attribut 
Utilisation

class className{ 
	protected var varName;
	protected const kName;
	protected function methodName() { 
		// your statements here 
	}
	protected namespace nsName;
}

Spécifie qu’une variable, une constante, une méthode ou un espace de noms est disponible uniquement pour la classe qui le définit, ainsi que pour toutes ses sous-classes éventuelles. La définition de protected dans ActionScript 3.0 est similaire à la définition de la version ActionScript 2.0 de private, à la différence que protected restreint l’accès pendant la compilation et l’exécution. Par défaut, une variable ou une fonction est disponible pour tout appelant au sein du même package. Utilisez ce mot-clé pour restreindre l’accès à une variable ou une fonction.

Ce mot-clé peut être utilisé uniquement dans les définitions de classe, pas dans les définitions d’interface. Vous ne pouvez pas appliquer private à une classe ou toute autre définition au niveau du package.

La définition de protected dans ActionScript 3.0 est plus restrictive que celle de protected dans le langage de programmation Java. Dans ActionScript 3.0 protected limite strictement l’accès aux sous-classes, tandis que dans Java protected autorise également l’accès à toute classe du même package. Par exemple, si une classe nommée Base contient une propriété marquée avec l’attribut protected, dans ActionScript 3.0, seules les classes qui étendent Base peuvent accéder à la propriété protégée. Dans le langage Java, toute classe appartenant au même package que Base peut accéder à la propriété protégée, même si la classe n’est pas une sous-classe de Base.

Paramètres
varName:* — Nom de la variable à spécifier en tant que protégée. Vous pouvez appliquer l’attribut protected uniquement si la variable est à l’intérieur d’une classe.
kName:* — Nom de la constante à spécifier en tant que protégée. Vous pouvez appliquer l’attribut protected uniquement si la constante est à l’intérieur d’une classe.
methodName:Function — Nom de la méthode à spécifier en tant que protégée. Vous pouvez appliquer l’attribut protected uniquement si la méthode est à l’intérieur d’une classe.
nsName:Namespace — Nom de l’espace de noms à spécifier en tant que protégé. Vous pouvez appliquer l’attribut protected uniquement si l’espace de noms est à l’intérieur d’une classe.

Exemple
Comment utiliser cet exemple
L’exemple suivant crée une variable de classe protégée dans la classe A et réussit à accéder à cette variable dans la classe B, car il s’agit d’une sous-classe de la classe A.
class A { 
  private var alpha:String = "visible only inside class A"; 
  protected var beta:String = "visible inside class A and its subclasses"; 
}
	
class B extends A {
  public function B() {
    beta = "Access attempt from subclass succeeded";
    trace(beta);  // Access attempt from subclass succeeded
  }
}

Eléments de l’API associés

publicMot-clé de l’attribut 
Utilisation

public var varName
public const kName
public function functionName()  { 
	// your statements here 
}
public class className {
	// your statements here 
}
public namespace nsName

Spécifie qu’une classe, une variable, une constante ou une méthode est disponible pour tout appelant. Les classes, les variables et les méthodes sont internes par défaut, ce qui signifie qu’elles ne sont visibles qu’à l’intérieur du package en cours. Afin de rendre une classe, une variable ou une méthode visible pour tous les appelants, vous devez utiliser l’attribut public.

Paramètres
className:Class — Nom de la classe à spécifier en tant que publique.
varName:* — Nom de la variable à spécifier en tant que publique. Vous pouvez appliquer l’attribut public, que la variable fasse partie d’une classe ou non.
kName:* — Nom de la constante à spécifier en tant que publique. Vous pouvez appliquer l’attribut public, que la constante fasse partie d’une classe ou non.
functionName:Function — Nom de la fonction ou méthode à spécifier en tant que publique. Vous pouvez appliquer l’attribut public, que la fonction fasse partie d’une classe ou non.
nsName:Namespace — Nom de l’espace de noms à spécifier en tant que public. Vous pouvez appliquer l’attribut public, que l’espace de noms fasse partie d’une classe ou non.

Exemple
Comment utiliser cet exemple
L’exemple suivant illustre l’utilisation de variables publiques dans un fichier de classe :
class User { 
	public var age:Number; 
	public var fname:String; 
} // end of class User definition
 
var jimmy:User = new User(); 
jimmy.age = 27; 
jimmy.fname = "jimmy";
trace(jimmy.age, jimmy.fname); // 27 jimmy
Si vous modifiez l’une des variables publiques de la classe User en variable privée, toute tentative d’accès à cette variable en dehors de la classe User génère une erreur de compilation.

Eléments de l’API associés

returnInstruction 
Utilisation

function functionName () {
	return [expression]
}

Renvoie immédiatement l’exécution à la fonction appelante. Si l’instruction return est suivie d’une expression, cette dernière est évaluée et le résultat est retourné.

Si une définition de fonction inclut un type de renvoi, l’instruction return doit être suivie par une expression. Si aucun type de renvoi n’est spécifié et que l’instruction return est utilisée seule, elle retourne undefined.

Vous ne pouvez pas retourner plusieurs valeurs. Dans ce cas, seule la dernière valeur est renvoyée. Dans l’exemple suivant, la valeur c est renvoyée :

return a, b, c ;

Si vous devez renvoyer des valeurs multiples, utilisez un tableau ou un objet.

Paramètres
expression:* — Expression à évaluer et retourner en tant que valeur de la fonction. Ce paramètre est facultatif.

Exemple
Comment utiliser cet exemple
L’exemple suivant utilise l’instruction return dans le corps de la fonction sum() pour retourner la somme des valeurs des trois paramètres. La ligne de code suivante appelle sum() et affecte la valeur renvoyée à la variable newValue.
function sum(a:Number, b:Number, c:Number):Number { 
	return (a + b + c); 
} 
var newValue:Number = sum(4, 32, 78); 
trace(newValue); // 114

Eléments de l’API associés

setMot-clé de la définition 
Utilisation

function set property(newValue:*) : void{ 
	// your statements here 
}

Définit une méthode setter, qui s’affiche dans l’interface publique en tant que propriété. Un setter est une méthode spéciale permettant de définir la valeur d’une propriété déclarée avec le mot-clé var. Contrairement aux autres méthodes, la méthode setter est appelée sans parenthèses (()), ce qui la fait ressembler à une variable.

Les méthodes setter permettent d’appliquer le principe de masquage des informations par la création d’une interface publique pour une propriété privée. L’avantage du masquage des informations est que l’interface publique reste identique même si l’implémentation sous-jacente de la propriété privée change.

Les méthodes setter présentent également l’avantage de pouvoir être remplacées dans des sous-classes, contrairement aux propriétés déclarées avec var.

Le type de retour d’une méthode setter doit être void ou non spécifié.

Un setter peut être combiné avec un getter pour former une propriété en lecture/écriture. Pour créer une propriété en lecture seule, créez un getter sans setter correspondant. Pour créer une propriété en écriture seule, créez un setter sans getter correspondant.

Paramètres
property:* — L’identificateur de la propriété modifiée par set. Cette valeur doit correspondre à la valeur utilisée dans la commande get correspondante.
newValue:* — Nouvelle valeur à affecter.

Exemple
Comment utiliser cet exemple
L’exemple suivant crée une propriété en lecture/écriture nommée age en définissant une méthode getter/setter.
package {
	class User { 
	    private var userAge:Number; 
	    
	    public function get age():Number {
	    	return userAge;
	    }
	    
	    public function set age(x:Number):void {
	    	userAge = x;	
	    }
	} 
} 
Entrez le code suivant dans le script :
var myUser:User = new User();
myUser.age = 25;
trace(myUser.age); // 25

Eléments de l’API associés

staticMot-clé de l’attribut 
Utilisation

class someClassName{ 
	static var varName; 
	static const kName;
	static function methodName() { 
		// your statements here
	} 
}

Spécifie qu’une variable, une constante ou une méthode appartient à la classe, et non aux instances de la classe.

Pour accéder à un membre de classe statique, utilisez le nom de la classe plutôt que le nom d’une instance. Par exemple, la classe Date comporte une méthode statique appelée parse(), pouvant être appelée uniquement à l’aide de la syntaxe suivante :

Date.parse()

La méthode parse() ne peut pas être appelée pour une instance de la classe Date. Par exemple, le code suivant génère une erreur :

var myDate:Date = new Date();
            myDate.parse("Jan 01 00:00:00 2006"); // error

Le mot-clé static peut être utilisé uniquement dans les définitions de classe, pas dans les définitions d’interface.

Les membres de classes statiques ne sont pas hérités. Vous ne pouvez pas faire référence à un membre de classe statique à l’aide du nom d’une sous-classe, comme en langage Java ou C++. Vous pouvez toutefois faire référence à une variable ou une méthode statique appartenant à une classe ou une sous-classe, sans avoir recours à des qualificateurs. Voir l’exemple ci-dessous.

Vous ne pouvez pas utiliser l’instruction super ou le mot-clé this dans une méthode statique.

Paramètres
varName:* — Nom de la variable à spécifier en tant que statique.
kName:* — Nom de la constante à spécifier en tant que statique.
methodName:Function — Nom de la méthode à spécifier en tant que statique.

Exemple
Comment utiliser cet exemple
L’exemple suivant illustre l’utilisation du mot-clé static pour créer un compteur chargé de suivre le nombre d’instances de la classe créées. La variable numInstances étant statique, elle est créée une seule fois pour l’ensemble de la classe, pas pour chaque occurrence distincte. Créez un nouveau fichier ActionScript nommé Users.as et entrez le code suivant :
class Users { 
	private static var numInstances:Number = 0; 
	function Users() { 
		numInstances++; 
	} 
	static function get instances():Number { 
		return numInstances; 
	} 
}
Entrez le code suivant dans le script :
trace(Users.instances); 
var user1:Users = new Users(); 
trace(Users.instances); 
var user2:Users = new Users(); 
trace(Users.instances); 
L’exemple suivant étend la classe Users pour montrer que les variables et méthodes statiques ne sont pas héritées mais peuvent être référencées dans des sous-classes.
class PowerUsers extends Users{
    function PowerUsers() {
        instances++;  // unqualified reference to static property Users.instances is legal
    }
}

trace(PowerUsers.instances); // error, cannot access static property using PowerUsers class

superInstruction 
Utilisation

super([arg1, ..., argN])
super.method([arg1, ..., argN])

Invoque la version superclasse ou parent d’une méthode ou d’un constructeur. Lorsque l’instruction super() est utilisée dans le corps d’un constructeur de classe, elle invoque la version superclasse du constructeur. L’appel du constructeur de superclasse doit disposer du nombre correct d’arguments. Notez que le constructeur de superclasse est toujours appelé, que vous en ayez fait la demande explicitement ou non. Si vous ne l’appelez pas de façon explicite, un appel sans arguments est inséré automatiquement avant la première instruction dans le corps du constructeur de la sous-classe. Cela signifie que si vous définissez une fonction constructeur dans une sous-classe et que le constructeur de superclasse prend un ou plusieurs arguments, vous devez appeler le constructeur de superclasse de façon explicite avec le nombre correct d’arguments pour ne pas provoquer une erreur. L’appel au constructeur de superclasse, toutefois, ne doit pas nécessairement être la première instruction du constructeur de sous-classe, comme c’était le cas avec ActionScript 2.0.

Lorsqu’elle est utilisée dans le corps d’une méthode d’occurrence, l’instruction super peut être utilisée avec l’opérateur point (.) pour invoquer la version superclasse d’une méthode et peut éventuellement transmettre des arguments (arg1 ... argN) à la méthode de superclasse. Ceci permet de créer des méthodes de sous-classe qui non seulement ajoutent des comportements supplémentaires aux méthodes de superclasse, mais les invoquent également pour exécuter leur comportement d’origine.

Vous ne pouvez pas utiliser l’instruction super dans une méthode statique.

Paramètres
method:Function — Méthode à invoquer dans la superclasse.
argN:* — Paramètres facultatifs transmis à la version superclasse de la méthode ou à la fonction constructeur de la superclasse.

Eléments de l’API associés

switchInstruction 
Utilisation

switch (expression) {
	caseClause: 
	[defaultClause:] 
}

Transfère le contrôle à l’une de plusieurs instructions en fonction de la valeur d’une expression. Toutes les instructions switch doivent inclure un cas par défaut exécuté si aucune des instructions case ne correspond à l’expression. Chaque instruction case doit se terminer par une instruction break, afin d’éviter les erreurs fall-through. Lorsque ce type d’erreur se produit, l’exécution du code se poursuit à la prochaine instruction case, même si elle ne correspond pas à l’expression de test.

Paramètres
expression:* — Toute expression.

Exemple
Comment utiliser cet exemple
L’exemple suivant définit une instruction switch qui se poursuit jusqu’au cas par défaut :
var switchExpression:int = 3;
		
switch (switchExpression) {
	case 0:
		trace(0);
		break;
	case 1:
		trace(1);
		break;
	case 2:
		trace(2);
		break;
	default:
		trace("Not 0, 1, or 2");
}

// Not 0, 1, or 2

Eléments de l’API associés

thisMot-clé de l’expression principale 
Utilisation

this

Référence à l’objet contenant une méthode. Lorsqu’un script s’exécute, le mot-clé this fait référence à l’objet contenant le script. Dans un corps de méthode, le mot-clé this fait référence à l’occurrence de classe contenant la méthode appelée.

Paramètres

Exemple
Comment utiliser cet exemple
Pour appeler une fonction définie dans une classe dynamique, vous devez utiliser this pour invoquer la fonction dans l’étendue appropriée :
// incorrect version of Simple.as
/*
dynamic class Simple {
    function callfunc() {
        func();
    }
}
*/
// correct version of Simple.as
dynamic class Simple {
    function callfunc() {
        this.func();
    }
}
Ajoutez le code suivant au script :
var simpleObj:Simple = new Simple();
simpleObj.func = function() {
	trace("hello there");
}
simpleObj.callfunc();
Le code précédent fonctionne lorsque vous utilisez this dans la méthode callfunc(). Vous obtenez toutefois une erreur de syntaxe si vous utilisez la version incorrecte de Simple.as, telle que commentée dans l’exemple précédent.

throwInstruction 
Utilisation

throw expression 

Génère ou renvoie une erreur pouvant être traitée ou interceptée par un bloc de code catch. Si une exception n’est pas interceptée par un bloc catch, la chaîne représentant la valeur renvoyée est transmise au volet Sortie. Si une exception n’est pas interceptée par un bloc catch ou finally, la chaîne représentant la valeur renvoyée est transmise au fichier journal.

Généralement, le système renvoie des instances de la classe Error ou de ses sous-classes (voir la section Exemple).

Paramètres
expression:* — Expression ou objet ActionScript.

Exemple
Comment utiliser cet exemple
Dans cet exemple, une fonction nommée checkEmail() vérifie si la chaîne qui lui est transmise est une adresse électronique correctement formatée. Si la chaîne ne contient aucun symbole @, la fonction renvoie une erreur.
function checkEmail(email:String) { 
	if (email.indexOf("@") == -1) { 
		throw new Error("Invalid email address"); 
	} 
} 
checkEmail("someuser_theirdomain.com");
Le code suivant appelle ensuite la même fonction checkEmail() au sein d’un bloc de code try. Si la chaîne ne contient pas une adresse électronique valide, le message d’erreur est retourné par l’instruction trace.
try { 
	checkEmail("Joe Smith"); 
} 
catch (e) { 
	trace(e); 
}
// Error: Invalid email address.
Dans l’exemple suivant, une sous-classe de la classe Error est renvoyée. La fonction checkEmail() est modifiée pour renvoyer une occurrence de cette sous-classe.
// Define Error subclass InvalidEmailError 
class InvalidEmailAddress extends Error { 
    public function InvalidEmailAddress() {
    	message = "Invalid email address."; 
    }
}
Entrez le code suivant dans le script :
import InvalidEmailAddress; 
function checkEmail(email:String) { 
	if (email.indexOf("@") == -1) { 
		throw new InvalidEmailAddress(); 
	} 
} 
try { 
	checkEmail("Joe Smith"); 
} 
catch (e) { 
	trace(e);
}
// Error: Invalid email address.

Plus d’exemples

Eléments de l’API associés

trueMot-clé de l’expression principale 
Utilisation

true

Valeur booléenne true. Une valeur booléenne est soit true soit false. L’opposé de true est false. Lorsque l’affectation automatique de données à un type convertit true en nombre, la valeur devient 1. Lorsqu’elle convertit true en chaîne, elle retourne "true".

Paramètres

Exemple
Comment utiliser cet exemple
L’exemple suivant indique l’utilisation de true dans une instruction if :
var shouldExecute:Boolean;
// ...
// code that sets shouldExecute to either true or false goes here
// shouldExecute is set to true for this example:

shouldExecute = true;

if (shouldExecute == true) {
    trace("your statements here");
}

// true is also implied, so the if statement could also be written:
// if (shouldExecute) {
//         trace("your statements here");
// }
L’exemple suivant illustre comment l’affectation automatique d’un type aux données convertit true en nombre 1 :
var myNum:Number;
myNum = 1 + true;
trace(myNum); // 2

Eléments de l’API associés

try..catch..finallyInstruction 
Utilisation

try { 
    // try block 
} finally { 
    // finally block  
} 

try { 
    // try block 
} catch(error[:ErrorType1]) {
    // catch block 
} [catch(error[:ErrorTypeN]) { 
    // catch block 
}] [finally {
    // finally block 
}]

Encadre un bloc de code pouvant provoquer une erreur, puis répond à l’erreur. Le traitement des exceptions, qui est implémenté à l’aide des instructions try..catch..finally, constitue le principal mécanisme de traitement des erreurs d’exécution d’ActionScript 3.0. Lorsqu’une erreur d’exécution se produit, Flash Player renvoie une exception. En d’autres termes, Flash Player suspend l’exécution normale et crée un objet spécial de type Error. Flash Player transmet ou renvoie ensuite l’objet d’erreur au premier bloc catch disponible. Si aucun bloc catch n’est disponible, l’exception est considérée comme une exception non interceptée. Ce type d’exception provoque une interruption du script.

Vous pouvez utiliser l’instruction throw pour renvoyer des exceptions de manière explicite dans le code. Vous pouvez renvoyer une valeur quelconque, mais la meilleure pratique consiste à renvoyer un objet, ce qui assure une certaine flexibilité et correspond au comportement de Flash Player.

Pour intercepter une exception renvoyée par Flash Player ou par votre propre code, placez le code susceptible de la renvoyer dans un bloc try. Si le code figurant dans le bloc try renvoie une exception, le contrôle passe au bloc catch, s’il existe, puis au bloc finally, s’il existe. Le bloc finally est toujours exécuté, qu’une exception ait été renvoyée ou non. Si le code du bloc try ne renvoie pas d’exception (si le bloc try se termine normalement), le code du bloc catch est ignoré, mais le code du bloc finally reste exécuté. Le bloc finally est exécuté même si le bloc try se termine à l’aide d’une instruction return.

Un bloc try doit être suivi d’un bloc catch, d’un bloc finally ou des deux. Un même bloc try peut comporter plusieurs blocs catch, mais un seul bloc finally. Vous pouvez imbriquer les blocs try sur autant de niveaux que nécessaire.

Le paramètre error spécifié dans un gestionnaire catch doit être un identificateur simple, tel que e, theException ou x. Le paramètre peut également disposer d’un type. Utilisés avec plusieurs blocs catch, les paramètres typés permettent d’intercepter plusieurs types d’objets d’erreur renvoyés par un même bloc try.

Si l’exception renvoyée est un objet, le type correspond lorsque l’objet renvoyé est une sous-classe du type spécifié. Si une erreur est renvoyée avec un type spécifique, le bloc catch traitant l’erreur correspondante est exécuté. Si une exception est renvoyée avec un type différent de celui spécifié, le bloc catch n’est pas exécuté et l’exception est automatiquement renvoyée en dehors du bloc try vers un gestionnaire catch correspondant.

Si une erreur est renvoyée au sein d’une fonction dépourvue de gestionnaire catch, Flash Player quitte cette fonction ainsi que toute fonction appelante, jusqu’à ce qu’il détecte un bloc catch. Pendant ce processus, les gestionnaires finally de tous les niveaux sont appelés.

Remarque : si dans un bloc try, un diffuseur d’événements appelle son gestionnaire d’événements, le bloc catch n’intercepte pas l’erreur si elle est renvoyée dans le gestionnaire d’événements. Toute erreur renvoyée peut être interceptée en écoutant LoaderInfo.uncaughtErrorEvents.

Paramètres
error:* — Expression renvoyée par une instruction throw, généralement une occurrence de la classe Error ou l’une de ses sous-classes.

Exemple
Comment utiliser cet exemple
L’exemple suivant illustre une instruction try..catch. Le code à l’intérieur du bloc try comprend une opération illégale. Un sprite ne peut pas s’ajouter en tant qu’enfant. Par conséquent, Flash Player renvoie une exception et transmet un objet de type ArgumentError au bloc catch correspondant.
import flash.display.Sprite;

var spr:Sprite = new Sprite();
try {
	spr.addChild(spr);
}
catch (e:ArgumentError) {
	trace (e); // ArgumentError: Error #2024: An object may not be added as a child of itself.
}
Dans l’exemple suivant, les objets RecordSetException et MalformedRecord sont des sous-classes de la classe Error.
class RecordSetException extends Error { 
	public function RecordSetException () {
		message = "Record set exception occurred."; 
	}
}

class MalformedRecord extends Error { 
	public function MalformedRecord {
		message = "Malformed record exception occurred."; 
	}
}
Dans la méthode sortRows() de la classe RecordSet, l’un des objets d’erreur définis précédemment est renvoyé selon le type d’exception rencontré. L’exemple suivant illustre un aspect possible de ce code :
class RecordSet { 
	public function sortRows() { 
		var returnVal:Number = randomNum(); 
		if (returnVal == 1) { 
			throw new RecordSetException(); 
		} 
		else if (returnVal == 2) { 
			throw new MalformedRecord(); 
		} 
	}
	public function randomNum():Number { 
		return Math.round(Math.random() * 10) % 3; 
	}
}
Enfin, le code suivant invoque la méthode sortRows() pour une occurrence de la classe RecordSet. Il définit des blocs catch pour chaque type d’objet d’erreur renvoyé par sortRows().
import RecordSet; 
var myRecordSet:RecordSet = new RecordSet();
try { 
	myRecordSet.sortRows(); 
	trace("everything is fine"); 
} 
catch (e:RecordSetException) { 
	trace(e.toString()); 
} 
catch (e:MalformedRecord) { 
	trace(e.toString()); 
}

Plus d’exemples

Eléments de l’API associés

use namespace Directives  
Utilisation

use namespace ns1[, ns2, ...nsN]

Implique l’ajout des espaces de noms spécifiés à l’ensemble des espaces de noms ouverts. Les espaces de noms spécifiés sont retirés de l’ensemble des espaces de noms ouverts lorsque le contrôle quitte le bloc de code en cours. La directive use namespace peut figurer au niveau supérieur d’un programme, d’une définition de package ou d’une définition de classe.

Paramètres
nsN:Namespace — Un ou plusieurs espaces de noms à ajouter à l’ensemble des espaces de noms ouverts.

Eléments de l’API associés

varMot-clé de la définition 
Utilisation

var variableName [= value1][...,variableNameN[=valueN]] 

Spécifie une variable. Si vous déclarez des variables au sein d’une fonction, elles sont locales. Elles sont définies pour cette fonction et expirent à la fin de l’appel de celle-ci.

Vous ne pouvez pas déclarer une variable figurant dans l’étendue d’un autre objet en tant que variable locale.

my_array.length = 25; // ok 
var my_array.length = 25; // syntax error 

Vous pouvez affecter un type de données à une constante en lui ajoutant un caractère deux points (:) suivi du type de données.

Vous pouvez déclarer plusieurs variables dans une même instruction, en séparant leurs déclarations par des virgules (bien que cette syntaxe risque de réduire la lisibilité du code) :

var first:String = "Bart", middle:String = "J.", last:String = "Bartleby";

Paramètres
variableName:* — Identificateur.

Exemple
Comment utiliser cet exemple
Le code ActionScript suivant crée un nouveau tableau de noms de produits. Array.push ajoute un élément à la fin du tableau.
var product_array:Array = new Array("Studio", "Dreamweaver", "Flash", "ColdFusion", "Contribute", "Breeze"); 
product_array.push("Flex"); 
trace(product_array); 
// Studio,Dreamweaver,Flash,ColdFusion,Contribute,Breeze,Flex

Eléments de l’API associés

whileInstruction 
Utilisation

while (condition) { 
	// statement(s)
}

Evalue une condition. Si elle est évaluée à true, exécute une ou plusieurs instructions avant de répéter la boucle et de réévaluer la condition. Dès que l’évaluation de la condition retourne false, les instructions sont ignorées et la boucle se termine.

L’instruction while exécute la série d’étapes suivante. Chaque répétition des étapes 1 à 4 constitue une itération de la boucle. La condition est testée au début de chaque itération, comme dans les étapes suivantes :

  1. L’expression condition est évaluée.
  2. Si condition est évaluée à true ou une valeur pouvant être convertie en une valeur booléenne true, telle qu’un nombre différent de zéro, passer à l’étape 3. Sinon, l’instruction while se termine et l’exécution reprend au niveau de la prochaine instruction suivant la boucle while.
  3. Exécuter le bloc d’instructions statement(s). Si une instruction continue est détectée, ignorer les instructions suivantes et passer à l’étape 1. Si une instruction break est détectée, l’instruction while se termine et l’exécution reprend au niveau de la prochaine instruction suivant la boucle while.
  4. Passer à l’étape 1.

Les boucles permettent habituellement d’exécuter une action tant qu’une variable de décompte est inférieure à une valeur spécifiée. Le compteur est incrémenté à la fin de chaque boucle, jusqu’à atteindre la valeur spécifiée. A ce moment, l’expression condition n’a plus la valeur true et la boucle se termine.

Les accolades ({}) encadrant les instructions à exécuter par l’instruction while sont facultatives s’il ne s’agit que d’une seule instruction.

Paramètres
condition:Boolean — Une expression dont la valeur est évaluée à true ou false.

Exemple
Comment utiliser cet exemple
Dans l’exemple suivant, l’instruction while permet de tester une expression. Lorsque la valeur de i est inférieure à 20, la valeur de i est représentée. Lorsque la condition n’a plus la valeur true, la boucle s’arrête.
var i:Number = 0; 
while (i < 20) { 
	trace(i); 
	i += 3; 
}
/*
0 
3 
6 
9 
12
15 
18
*/

Eléments de l’API associés

withInstruction 
Utilisation

with (object:Object) { 
	// statement(s)
}

Etablit un objet par défaut à utiliser pour l’exécution d’une ou plusieurs instructions, ce qui peut permettre de réduire le volume de code à écrire.

Le paramètre object devient le contexte de lecture des propriétés, variables et fonctions du paramètre statement(s). Par exemple, si object correspond à my_array et que deux des propriétés spécifiées sont length et concat, ces propriétés sont automatiquement lues comme my_array.length et my_array.concat. Un autre exemple : si object correspond à state.california, toutes les actions et instructions contenues dans l’instruction with sont appelées depuis l’intérieur de l’occurrence california.

Pour déterminer la valeur d’un identificateur dans le paramètre statement(s), ActionScript commence au début de la chaîne d’étendue spécifiée par object et recherche l’identificateur à chaque niveau de la chaîne de domaine, dans un ordre spécifique.

La chaîne d’étendue utilisée par l’instruction with pour la résolution des identificateurs commence par le premier élément de la liste suivante et se poursuit jusqu’au dernier :

  • Objet spécifié dans le paramètre object de l’instruction with de plus bas niveau.
  • Objet spécifié dans le paramètre object de l’instruction with de plus haut niveau.
  • Objet Activation (objet temporaire créé automatiquement lorsque le script appelle une fonction contenant les variables locales appelées dans la fonction).
  • Objet contenant le script en cours d’exécution.
  • Objet Global (objets intégrés, tels que Math et String).

Pour définir une variable dans une instruction with, vous devez avoir déclaré cette variable en-dehors de l’instruction with, ou vous devez entrer le chemin complet du scénario cible d’existence de la variable. Si vous définissez une variable dans une instruction with sans la déclarer, l’instruction with recherche sa valeur en fonction de la chaîne d’étendue. Si la variable n’existe pas encore, la nouvelle valeur est définie sur le scénario à l’origine de l’appel de l’instruction with.

Paramètres
object:Object — Occurrence d’un objet ou d’un clip ActionScript.

Exemple
Comment utiliser cet exemple
L’exemple suivant définit les propriétés _x et _y de l’occurrence someOther_mc, puis indique à someOther_mc de passer à l’image 3 et de s’arrêter. with (someOther_mc) { _x = 50; _y = 100; gotoAndStop(3); } Le fragment de code suivant illustre l’écriture du code précédent sans utilisation de l’instruction with. someOther_mc._x = 50; someOther_mc._y = 100; someOther_mc.gotoAndStop(3); L’instruction with permet d’accéder simultanément à plusieurs éléments d’une liste de chaîne d’étendue. Dans l’exemple suivant, l’objet Math intégré est placé au début de la chaîne d’étendue. La définition de Math comme objet par défaut convertit respectivement les identificateurs cos, sin et PI en Math.cos, Math.sin et Math.PI. Les identificateurs a, x, y et r ne sont ni des méthodes ni des propriétés de l’objet Math, mais puisqu’ils existent dans l’étendue d’activation d’objet de la fonction polar(), ils renvoient aux variables locales correspondantes.
function polar(r:Number):void { 
	var a:Number, x:Number, y:Number; 
	with (Math) { 
		a = PI * pow(r, 2); 
		x = r * cos(PI); 
		y = r * sin(PI / 2); 
	} 
	trace("area = " + a); 
	trace("x = " + x); 
	trace("y = " + y); 
} polar(3);
/* 
area = 28.2743338823081 
x = -3 
y = 3
*/

[ X ]Pourquoi existe-t-il du contenu en anglais ?
Certaines parties du Guide de référence ActionScript 3.0 sont en anglais

Tout le contenu du Guide de référence ActionScript 3.0 n’a pas été traduit dans toutes les langues. Si un élément de langage n’est pas traduit, il s’affiche en anglais. Par exemple, la classe ga.controls.HelpBox n’est traduite dans aucune langue. Ainsi, dans la version française du guide de référence, la classe ga.controls.HelpBox apparaît en anglais.