Autor: Rodrigo Gonçalves

Package: flash.net
Classe: public class URLLoader

Versão AS: ActionScript 3.0
Player: Flash Player 9

Dificuldade: Médio.
Obs: Para um bom aproveitamento deste artigo é interessante ter noções de XML, Actionscript 3.0, conceitos de Array e lógica de programação.

Fala galera, tranquilo?!

Vamos ver como carregar um arquivo XML com AS3. Dividimos por 2 etapas. Sendo elas:

Na 1º etapa, é a Introdução onde iremos falar um pouco do XML e algumas caracteristicas do AS3 com XML. Esta 1º etapa, está dedicada mais para quem está iniciando com XML.
É um assunto bastante amplo e não será o nosso foco principal falar de XML. Existe sites e até livros específicos sobre XML onde você pode buscar maiores detalhes sobre isso.
Mas antes, precisamos conhecer o básico de um XML, isso para aproveitarmos de uma melhor forma o AS3 em conjunto com XML.
Falaremos também um pouco da caracteristica de um Array a qual será fundamental ter esse conceito no Actionscript. Caso você já tenha conhecimentos equivalentes, sinta-se avontade para seguir para próxima etapa.

Na 2º etapa, o foco está destinado a criação de um Documento XML externo, e como fazer leitura desse XML utilizando o AS3.

Índice:

2 - Criando um Documento XML;
3 - Lendo elementos do XML;
- 3.1 - Pegando um atalho…;
- 3.2 - Acesso a Elementos de nomes iguais;
- 3.3 - Descobrindo a quantidade de Elementos;
- 3.4 - Usando Loop for each;
- 3.5 - Encontrando Atributos de um Elemento;
4 - Carregando XML externo.

Etapa 1

1 - Introdução

Provavalmente você já deve ter escutado alguma vez na vida a palavra XML(eXtensible Markup Language), e quando trabalhar com Web certamente vai escutar frequentemente este nome. Quando falarmos em arquivos externos, o XML é um ótimo exemplo. Também podemos considerá-lo fácil para representar informações mais "complexas". Isso, graças ao seu formato "único" que pode ser criado e facilmente entendido ou interpretado tanto por Computadores quanto por Humanos.

Também o XML pode ser conhecido como "Árvore XML" por representar em seu formato como uma Hierarquia, tendo suas "ramificações" e seus respectivos Nós XML contendo uma ou mais informações. Se você já conhece HTML terá grande facilidade pra entender o XML.

Com certeza o XML não é a única maneira de carregar uma informação externa no Flash.

O XML apresenta algumas vantagens mais conhecidas:

* Podemos criar dados de XML manualmente(estáticos) ou por programação(dinâmicos), como por exemplo usar um script de PHP ou um outro script de Server-Side, que faz leitura de uma banco de dados para escrever um Documento XML. Além de poder ser bem mais "fácil" representar informações mais "complexas" utilizando um XML.

* Muitas linguagens Server-Side-Script(Ex: PHP) oferece funcionalidades para ler e gerar dados em XML.

* XML é bastante usado e até considerado um "Padrão web" para transferir e armazenar dados que pode ser interpretado/visualizado em vários tipos de aplicações, plataformas, browsers e até por pessoas sem necessidade de grandes conhecimentos em programação. O XML oferece uma "liberdade" para criar um "padrão" na criação de suas informações, podendo até mesmo facilitar na sua organização.

* Podemos também criar quaisquer nomes que precisarmos para os Elementos(Nós) e Atributos de XML, tendo uma particularidade única para cada Documento XML que for criado, respeitando suas hierarquias e regras de criação para o mesmo.

Nas próximas partes veremos alguns exemplos passando apenas o conceito do XML e leitura de dados do AS3.

1.0 - Senta que lá vem a história

Iremos ver alguns conceitos do XML e AS3 antes de ir diretamente pro código XML e Actionscript. É muito importante pegar o conceito para nos ajudar na prática.

Imagine uma família, que tem uma hierarquia para ter acessos até aos seus Filhos. Partindo deste princípio, podemos dizer que os membros de uma família passa de Pais pra Filhos, de Filhos para Netos e assim por diante. Exatamente como uma "Árvore hierárquica". Veremos alguns exemplos, e mais pra frente, a criação de um Documento XML que será mostrado na próxima etapa, onde faremos o Flash “ler” via Actionscript um XML externo.

A explicação de um exemplo logo abaixo será feita partindo do "ponto de vista" dos "Pais".
No XML, normalmente a referência de hierarquias são sempre feita de "nó XML Pai" para "nó XML Filho". Neste exemplo citado abaixo foi utilizado Hierarquia como exemplo: Pai > Filho >> Neto >>> Bisneto…etc, para tentar facilitar no entendimento do conceito das hierarquias utilizadas no XML.

Observe a seguinte estrutura deste "laço de família".

Ex.:

- Pais (onde tudo começa, nasce uma família)

— Filho (nasceu o 1º filho dos Pais)
—– Neto (chegou mais um membro na família. Esse 1º Neto ainda não tem filhos)
—– Neto (Este 2º neto está animado e nasce mais um membro na família)
——- Bisneto (essa família ta crescendo. Pode vir mais gente por aí…)
—– Neto (fecha o "laço" do 2º Neto)
— Filho (fecha o "laço" do 1º Filho)

— Filho (o 2º filho veio em seguida. Os dois Filhos são gêmeos idênticos. Será que vai ter confusão?)
—– Neto ( esse Neto não vai querer ter filhos)
– Filho (fecha o "laço" do 2º Filho)

— Filho3 (esse Filho não é gêmeo. Ele também não quer ter filhos agora)

- Pais (fecha o "laço" de toda família)

Certamente você já deve ter notado uma Hierarquia de "poder" e acessos, ou se preferir dizer: "diferentes níveis".
Até aí está bem. Mas, o que isso tem haver com o XML? E ainda mais, o que tem haver com AS3 em conjunto com XML?

Podemos dizer que o XML trabalha por "Hierarquia de acessos" para poder chegar/encontrar uma certa informação que precisamos. Já o AS3, solicita "nomes" de cada membro(Nó XML) que foi criado para ter acesso até as informações de cada Nó XML.

Vejamos um breve exemplo logo abaixo como poderiamos representar este caso da familia em um arquivo XML.

Imagem: Exemplo de arquivo XML e sua respectivas informações.

Não irei explicar como foi feito o XML em si, apenas mostraremos para você conhecer uma estrutura de XML. Vale lembrar também que, não será o nosso foco neste artigo falar como criar um arquivo XML. Mas, é interessante ter alguns conceitos de um XML as quais nos ajudarão quando formos trabalhar com Actionscript para "manipular" um XML. Caso queira conhecer mais sobre XML obter mais detalhes, vale a pena conhecer este site: w3schools.com/xml (inglês).

Continuando…
Respeitando essa hierarquia dessa "família"(o XML). Existe algumas regras que este grupo familiar estabeleceu. Por exemplo, digamos que essa familia é bastante "exigente", e precisamos ter certos cuidados, e pedir "permissões" para os Pais deixarem obter informações de um Filho, Neto, Bisnetos, etc.

Também, cada "membro"(um Nó XML) desta família, poderá ter uma ou vários atributos/propriedades, podendo conter informações particulares caso for necessário.
Para conseguirmos ter acesso a uma informação específica do 1º Bisneto desta família no Actionscript. Antes teremos que passar pelos Pais, em seguida pelo 1º Filho(um dos gêmeos), depois pelo 2º Neto desse 1º Filho, e só depois de passar por todos, conseguimos obter alguma informação com o 1º Bisneto.

Exemplo de acesso sequencial:
Pais > 1º_Filho >> 2º_Neto >>> 1º_Bisneto

Percebeu o controle da situação? Família bem "exigente" está. Não é?
Podemos dizer que o XML é exigente também, bastante exigente e não permite erros. Se não formos organizados, certamente iremos ter problemas com XML.

Se você tentar ir direto ao 1º Bisneto sem antes "pegar" informações/permissões seguindo a ordem de hierarquia. Podemos não ter uma referência de acesso até este membro. também não teriamos certeza de onde esse 1º Bisneto veio, de qual Filho ele pertence gerando uma confusão. Além de ter dificuldades para encontrá-lo de forma mais segura e ter acesso mais facilmente até o mesmo.

Agora está começando a ficar mais clara essas informações? Ainda não?
Você gostaria de outro exemplo de uma outra história?

Tudo bem. A história poderia ser quaisquer temas que você desejar ou imaginar, com qualquer informação que precisar e da maneira que preferir organizar. Tudo pode depender da sua necessidade de passar uma ou mais informações. Isso porque o XML permite essa "liberdade" de criação. Mas claro, sempre respeitando sua hierarquia de acessos e logicamente, respeitando as regras de criação de um Documento XML.

Voltando um pouco para a realidade do Flash. Quando formos associar o arquivo XML com o Flash, acredito que vai fazer sentido esse conceito de hierarquias como este entre outros vários exemplos que podemos encontrar na Web com XML. Principalmente se for a primeira vez que você está conhecendo XML e ainda mais em conjunto com AS3(Actionscript 3.0).

Na versão AS3, a melhorias que teve com XML são notáveis comparado com sua versão anterior do AS2.
Você poderá ter acesso diretamente por nomes de cada Nó do XML(linha do XML), facilitando não só na sua organização mas também no seu entendimento e organização do código.

A seguir, falaremos um pouco de algumas nomenclaturas mais utilizadas no XML com Flash.

1. 1 - Algumas nomenclaturas de XML

Existe algumas nomenclaturas que são bastante usadas quando falarmos em XML, e estas "nomenclaturas", nos ajudarão no entendimento deste tópico pra leitura de um Documento XML externo em conjunto com o Flash. Algumas dos nomes mais utilizados são:

* Documento XML (XML Document):
Geralmente usado quando se referimos em "enviar" ou "carregar" um Documento XML ou apenas para falar sobre ele. Podemos considerar este Documento sendo o arquivo XML propriamente dito (exemplo.xml). Também não podemos confundir com a Classe XMLDocument que está presente no AS3.

* Declaração XML (XML Declaration):
É a parte inicial quando escrevemos um Documento XML. Utiliza uma Tag especial <?xml ?>, e com esta Tag podemos acrescentar atributos que descreve por exemplo que tipo de versão você utiliza do XML e a sua codificação. A Declaração XML ajuda na interpretação da leitura do XML. Está Tag especial não pode ser considerado como um Elemento XML(um Nó XML).

Um dos exemplos bastante utilizado para o inicio do XML. Ex.:

Versão 1.0 do XML
<?xml version="1.0" ?>

Ou com:

Codificação de letras, padrão para línguas ocidentais iso-8859-1
<?xml version="1.0" encoding="iso-8859-1" ?>

Obs.: Existe outros tipos de codificações, se quiser você pode conhecer um pouco mais a Lista de codificação no Wikipedia ou em pesquisas em sites específicos.

* Raiz XML ou Árvore XML (XML Tree):
Também conhecido como "Data tree"(Informação raiz). Um Raiz XML, podemos dizer que é a hierarquia de todos os seus respectivos Nós XML que foram criados em um Documento XML.

Representado no exemplo abaixo com a Tag na cor Vermelha.
Ex:
<?xml version="1.0" ?>
<RaizXML>
     <nóRaiz>
          <elementoXML> meu texto 1 aqui </elementoXML>
          <elementoXML> meu texto 2 aqui </elementoXML>
          <elementoXML> meu texto 3 aqui </elementoXML>
     <nóRaiz>
</RaizXML>

* Nó Raiz (Root Node):
É um Elemento que está geralmente no topo do Documento XML ou é o Nó principal de uma grupo de Nós XML, respeitando a sua Hierarquia para conseguir referenciar um ou mais Elementos XML que você criar dentro deste Nó Raiz.

Representado no exemplo abaixo com a Tag na cor Vermelha. Ex:
<?xml version="1.0" ?>
<RaizXML>
     <nóRaiz>
          <elementoXML> conteúdo 1 </elementoXML>
          <elementoXML> conteúdo 2 </elementoXML>
          <elementoXML> conteúdo 3 </elementoXML>
    </nóRaiz>
</RaizXML>

* Nó XML (XML Nodes):
Um XML é composto por um ou vários Nós XML. Quando falamos em "Nós do XML" podemos considerar como uma espécie de "bloco de informações". E neste "bloco de informações" pode conter um ou mais "Elementos XML", "Nó de textos", "Atributos", entre outros tipos. Os dois nomes "Elemento XML" e "Nó de texto" podemos considerar simplismente como o "Nó XML"(Nodes), e geralmente o termo Atributo está inserido dentro de um Nó XML.

Representado no exemplo abaixo com a Tag na cor Vermelha. Ex:
<?xml version="1.0" ?>
<RaizXML>
     <nóRaiz>
          <elementoXML> conteúdo 1 </elementoXML>
          <elementoXML> conteúdo 2 </elementoXML>
          <elementoXML> conteúdo 3 </elementoXML>
    </nóRaiz>
</RaizXML>

* Elementos XML (XML Element):
Os "Elementos XML" podemos considerar como "Tags", um termo bastante usado para o HTML, já que o XML tem uma grande "famíliaridade" com a aparência de um arquivo HTML. Podemos criar diversos Elementos XML com nomes iguais ou diferentes. Conseguir ler apenas o Elemento XML que nos interessa no momento.

Este Elemento XML pode também ser escrito de duas formas. Sendo elas:

Abrindo e fechando Tag. Criando uma Tag para abrir um Elemento < > e em seguida criar outra Tag que Fecha o mesmo elemento criado </ >. Geralmente este tipo de Elemento existe um conteúdo inserido entre a Tag criada. Podemos também acrescentar Atributos/propriedades dentro da Tags de abertura caso achar necessário.
- Sintaxe: <abre a tag do Elemento> escreve o conteúdo e </fecha a tag com o mesmo nome do Elemento>
- Ex.: <elemento> conteúdo </elemento>

Ou abrindo e fechando na mesma Tag, geralmente este tipo de Elemento contém um ou mais "Atributos" inseridos dentro da Tag, e também quando não queremos colocar necessariamente "valores"(ex: informações) entre um Elemento.
- Sintaxe: <abre e fecha e na mesma tag com o barra pra direita no final />
- Ex.: <elemento meuAtributo="valor do atributo"/>

* Atributo XML (Attribute):
Podemos chamar o "Atributo XML" como sendo uma "parte" ou "propriedade" de um Elemento criado. Geralmente carrega uma "particularidade" que queremos acrescentar em um determinado Elemento XML que for criado.
Devem ser referenciados sempre dentro do Elemento XML e não entre as Tags do mesmo. Você pode criar quantos Atributos precisar, mas sempre com nomes diferentes de atributos quando utilizado dentro do mesmo Elemento, isso pra evitar conflitos/confusões quando for fazer leitura de conteúdo. O Valor de cada Atributo geralmente deve ser colocado entre aspas duplas (" ").
- Sintaxe: NomeDoAtributo="Valor do Atributo"
- Ex.:
<elementoXML idade="Tenho 10 anos." Nome="Fulano de Tal">
     O Fulano de Tal nasceu do Ciclano de Tal.
</elementoXML>

* Nó de Texto (Text Node):
É basicamente um conteúdo de texto que está inserido dentro de um Nó XML. Neste Nó XML pode também conter outros "Elementos XML" que você pode criar, e estes Elementos "alimenta" o conteúdo deste Nó XML como se fosse um "recheio de informações" do mesmo.

No exemplo abaixo, no primeiro nóDeTexto1 contém apenas 1 Nó XML com seu respectivo Textos. Já no segundo nóDetexto2 definimos com mais 3 Nó XML com seu respectivo Textos para "rechear" ele, e no nóDetexto3, existe apenas um texto.
- Ex.:
<?xml version="1.0" ?>
<RaizXML>
     <nóRaiz>
         <nóXML1>
              <elemento> meu texto ou informação aqui </elemento>
         </nóXML1>

         <nóXML2>
               <elementoXML> meu texto aqui </elementoXML>
               <elementoXML> aqui vai outro conteúdo </elementoXML>
               <elementoXML atributo="Valor"> escrevo o que eu precisar </elementoXML>
         </nóXML2>

         <nóDeTexto>
               Meu conteúdo de texto.
               um Nó de Texto também é considerado como um Elemento XML.
         </nóDeTexto>
     </nóRaiz>
</RaizXML>

* CDATA:
O CDATA nos permite que inserirmos outras informações entre uma Tag XML sem que seja interpretado pelo XML. podemos dizer que o CDATA funciona como uma espécie de [cápsula].
Ou seja, o XML irá entender o conteudo do Nó XML sendo como um Nó de Texto ignorando quaisquer códigos inseridos entre um um Elemento XML.
Por exemplo, as vezes podemos querer inserir formatação de texto utilizando Tag de HTML. Devemos utilizando os sinais de "<" e ">" para inserir as tags HTML, isso pro XML é entendido como abertura ou fechamento de um Nó ele não identificará que é uma tag de negrito e sim um Nó XML criado por você com nome de <b></b>.
Caso queira formatar o texto com Tags Simples de HTML, podemos deixar da seguinte maneira utilizando o CDATA:

- Sintaxe: <![CDATA[ informação de texto ]]>
- Ex.:
<elementoXML>
     <![CDATA[ <b> meu texto em formatação HTML</b> ]]>
</elementoXML>

Obs.: Mas tenha atenção se carregar no Flash conteúdo formatado com HTML. O Flash Player tem algumas restrições com algumas Tags de HTML.
Procure no Help do Flash(atalho F1) pela propriedade htmlText da classe TextField do AS3 para obter mais informações das Tags HTML que o Flash Player suporta.

Vale também lembrar que, os nomes das Tags informadas logo acima no XML são apenas sugestivos pra tentar nos facilitar no entendimento da sintaxe do XML. Você pode criar quaisquer nomes que precisar mas sempre respeitando as hierarquia e maneira criação de um Documento XML.

No XML devemos tomar alguns cuidados na criação de nomes de Tags e Atributos:

- Não deve iniciar com Números os nome de tags e atributos, apenas usar números depois que inserir a primeira letra;
- Não utilizar caracteres especiais para os nomes de Tags e atributos como: (!?@\ /#$%&*",;[] ‘ +-), exceto para o sinais de menos/hífen ( - ) ou underline/underscore ( _ ) geralmente usados para unir palavras;
- Não podemos utilizar espaços entre os nomes da Tags;
- O XML é Case Sensitive(sensível ao tamanho da letra) para nomes de Tags. Ele diferencia de letras minúsculas
e maiúscula.

O XML é uma linguagem bastante "franca". Por exemplo, experimente errar propositadamente a digitação quando estiver criando Tags e Atributos do XML, e em seguida salve com um nome e extensão ".xml" e tente visualizar o arquivo no Browser, ele logo irá mostrar algo errado. Sinta-se digamos "agradecido" ao XML, ele nos ajuda evitar e mostrar erros que as vezes passam despercebidos aos nossos olhos quando fazemos esta simples verificação no Browser.

1.2 - Falando um pouco de Array

Aproveitando este mesmo conceito da história da família, vamos dar um pequeno exemplo utilizando uma linha de código do AS3 para ler um arquivo XML, a principio apenas para adaptarmos neste conceito de Arrays que é muito importante para manipular informações de um XML no Actionscript. Vale a penas olhar o "Help" do Flash(tecla F1) para obter mais informações da classe Array() pra conhecer melhor.
Um Array nos ajuda a organizar e ter acesso as informações de forma ordenada.

Retomando a história da família, para conseguiriamos chegar por exemplo até ao 1º Bisneto desta família, seria da seguinte forma:

Se antes eu preciso seguir este caminho/lógica e ordem de acesso por hierarquia, separando cada membro por "níveis".
Ex.:
Pais > 1º_Filho >> 2º_Neto >>> 1º_Bisneto
nível 1 > nível 2 >> nível 3 >>> nível 4

No AS3 para ler o XML e chegar até o 1º Bisneto, seria da seguinte forma(separando os elementos no AS utilizando Pontos). Ex.:
meuXML.Filho[0].Neto[1].Bisneto

O nome "meuXML" são extamente os "Pais" do XML, no AS não precisamos colocar o nome da Raiz do XML. Isso porque esse meuXML(poderia ser qualquer nome), é um nome de instância que criamos via Actionscript a partir da classe XML.
Quando falamos em um nome de instância que é criada a partir da classe, podemos dizer que está instância passa agora a ter as propriedades e métodos
da classe que for criada.
No nosso caso a Classe XML.
E Esta classe XML do AS3 possui suas propriedades e métodos para ter acesso à um Documento XML.
Este "meuXML" nada mais é que, a "Raiz" do arquivo XML. Digamos que, o objeto "meuXML" é o arquivo XML propriamente dito(a família e toda sua hierarquia de acessos).

Perceba também que foi inserido número inteiro entre cada Colchetes [ ], sendo que essa família tem os dois Filhos exatamentes iguais(gêmeos) e o 3º Filho diferente a qual não foi referenciado agora. Ou seja, isso significa que poderiamos ter Nós XML exatamente com mesmos nomes ou com diferentes nomes e quantidades de Nós XML que quisermos criar.
Mas, caso você tenha que trabalhar com nome de Nós de XML exatamente com nomes iguais.
Para chamar cada Nó XML pelo Actionscript, devemos utilizar um tratamento de Array[ ].

No Actionscript existe dois tipos de Arrays que usam diferentes maneiras para acessar as informações(elementos). São estas:

- Associative Array:
Que utiliza uma palavra chave "associativa" para ter acesso a cada elemento/informação.

- Integer-index-Array:
Que utiliza números inteiros, sendo que cada número é um único identificador para cada elemento que queremos referenciar. Começando sua contagem a partir do 0(zero), ordenada por um número a qual podemos chamar este número de "Index".

O mais conhecido e mais utilizado do Array geralmente é o Integer-index-array. Esta opção é excelente escolha caso você precise recuperar informações de forma ordenada. 0, 1, 2, 3, 4 … N Elementos. E será Integer-index-array que iremos usar aqui.

Um exemplo de Integer-index-Array:

Imagina a casa dessa mesma família, onde existe muitos quartos na casa. Podemos considerar esses quartos um "Grupo de quartos". E cada quarto desse grupo, passa a ser automaticamente enumerado em um grande corredor. Ex.: Quarto 0 , Quarto 1, Quarto 2, etc.
Se colocarmos uma ordem por sequência numérica, passariamos então a ter maior controle de acessos a cada quarto desse "Grupo de quartos". A contagem de um objeto do tipo Array é feita a partir do 0(zero).

Exemplo, logo abaixo no código AS, criamos um objeto com nome de instância "Quarto" que é a partir da Classe Array(). E em seguida mostra seus valores de cada elemento do Array na caixa de saída(Output). Crie um novo documento Flash, no 1º frame abra o painel de Actions(atalho F9) e digite:

1
2
3
4
5
6
7

//criamos o Array
var Quarto:Array = new Array("1º quarto", "2º quarto", "3º quarto");
 
//retorna valores de cada elemento Array
trace( Quarto[0] ); // 1º quarto
trace( Quarto[1] ); // 2º quarto
trace( Quarto[2] ); // 3º quarto

Resultado deve ter ficado da seguinte forma:

Imagem 1: Montando um exemplo de Array e recuperando valores de cada elemento que foi criado.

Poderiamos ter N valores que podemos separá-los os elementos por virgulas e desta maneira você consegue "alimentar" um Objeto Array e chamar um Elemento específico quando existe varios do mesmo grupo de nomes.
Ex.: nomeDoGrupoArray[ número do elemento ]

Podemos também inserir valores como: Strings(textos), Boolean(true ou false), Números, ou referenciar um nome de outros Objetos que forem criados.

E ainda podemos ir mais além nisso. Agora aplicando o conceito desse Arrays em um XML. Se for uma situação pequena até que não teriamos grandes problemas na organização. Mas se por acaso em cada quarto, ter mais um "grupo de informações" inserido em cada quarto. E esses grupos tem os mesmos nomes. Então precisamos enumera-los para ter alguma referencia dentro de cada grupo.
Ou seja, cada quarto pode ter ou não banheiros, ou ainda ter um ou vários armários, e em cada armário ter uma ou várias gavetas…

…Está começando a complicar. Não é?

Justamente por isso, o Array nos ajuda e muito na organização do Actionscript para obter uma determinada "informação" específica de um "lugar" específico de um "grupo" que queremos encontrar.
Principalmente no nosso caso que utilizamos o Actionscript para "ler" um Documento XML. O Array usa esse conceito de organização para XML com nomes iguais, e no XML o tratamento de Arrays associa os números inteiros que estão entre os Colchetes da minhaArray[ ] para localizar a uma "linha do XML" que tem nomes iguais nas suas Tags XML. Mais especificamente, um Nó XML com nomes de Tags iguais.
Mas também, poderiamos fazer nomes diferentes(únicos) no XML para cada Nó XML. Depende mesmo da sua necessidade e preferência de organização.

Com Arrays podemos resolver facilmente uma situação mais ampla.
Por exemplo, vamos aproveitar esta mesma situação da Casa:

Preciso pegar algumas Roupas que estão em uma gaveta a qual ainda não sabemos. Mas antes, preciso saber as coordenadas ou o passo-a-passo para chegar até o meu objetivo.
Recebi a informação que, as "Minhas Roupas" estão na 2º Gaveta do 5º Armário, que por fim está no 3º Quarto do 2º Corredor desta Casa.

No nosso documento XML está situação ficaria descrita da seguinte forma.
Foram criados tags de acordo com grupos que foi determinado. Também acrescentamos alguns Atributos em alguns Elementos XML, isso para poder referenciar alguma informação "extra" ou "particularidade" de uma Tag específica. Estes Atributos podemos dizer que são como "pistas".(Até parece coisa de "detetive").

O
Documento XML que denominamos de "casa.xml":

Imagem 2: Documento XML.

E no código AS3 consigo chegar até a informação do XML referenciando cada Nó XML pelo seus nomes de Tags e Atributos. Caso houver Nós XML criados com mesmo nomes, utilizamos "números inteiros" do Array para referenciar a cada elemento do XML. Lembra do Integer-index-Array? Começamos a contagem a partir de 0(zero).
Vale lembrar que os nomes de Tags do XML são Case Sensitive. No Actionscript também devemos respeitar isso. Ficando desta forma no AS3

meuXML.Corredor[1].Quarto[2].Armario[4].Gaveta[1];

O meuXML é um Objeto da classe XML do Actionscript a qual recebe informações de um arquivo Externo (casa.xml). Onde este "meuXML" é exatamente a tag <Casa></Casa>, justamente o "Nó Raiz" do Documento XML.

Acredito que o AS3 com XML facilitou a vida. Não é?

Claro que este código AS3 está incompleto. Se tentar fazer algo somente com essa linha não conseguimos carregar nada tendo apenas estas informações.
Agora que o conceito do XML e Arrays está um pouco em nossa mente. Vamos ao Actionscript.
Na próxima etapa iremos criar um Arquivo XML(casa.xml) e fazer o código AS3 ler esse mesmo exemplo.

Etapa 2

2 - Criando Documento XML

Abra um bloco de notas ou o seu editor de códigos, dê o nome para este arquivo XML de casa.xml.
salve-o o seu Documento XML na mesma pasta do seu arquivo ".Fla" e ".Swf".

Digite:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

<?xml version="1.0"?>
<Casa>
	<Corredor informacao="nao tem quartos aqui"/>
	<Corredor informacao="tem 3 quartos">
		<Quarto informacao="quarto vazio" />
		<Quarto informacao="quarto vazio" />
		<Quarto informacao="tem 5 armarios aqui">
            <Armario informacao="sem gavetas" />
            <Armario informacao="sem gavetas" />
            <Armario informacao="sem gavetas" />
            <Armario informacao="sem gavetas" />
            <Armario>
				<Gaveta informacao="esta vazia" />
				<Gaveta>
					Minhas Roupas
				</Gaveta>
 
			</Armario>
		</Quarto>
	</Corredor>
</Casa>

Seu Documento XML deve ter ficado algo parecido com a imagem 3:

Imagem 3: Criando um Documento XML com nome de "casa.xml".

Com seu arquivo XML devidamente criado. Vamos ler estas informações com Actionsript 3.0.

Dica:
Salve o arquivo XML e Flash em uma pasta para uma melhor organização dos arquivos.

3 - Encontrando elementos do XML

Antes de carregarmos um arquivo XML externo, vamos fazer alguns exemplos que nos ajudará entender melhor o Actionscript 3.0 com XML.

Iremos gerar o conteúdo XML inserindo no próprio Actionscript. Depois de pegarmos alguns conceitos desses exemplos partiremos para o exemplo externo.
Sinta-se a vontade em pular as etapas se você achar necessário.

Crie um novo documento Flash na versão Actionscript 3.0 e salve com o nome "lendo_elementos_xml.Fla". Clique na primeira Layer e dê o nome de "Actions".
Em seguida selecione o primeiro frame e abra o painel de Actions Window > Actions (atalho F9). Na 1º linha, digite:

1
2
3
4
5
6
7

var meuXML:XML = 
<meuXML>
	<linha>
		Conteudo
	</linha>
</meuXML>
trace(meuXML);

Em seguida teste o filme (Ctrl+Enter). Você pode perceber que na caixa de Saída aparece o XML inteiro.
Na 1º linha, criamos uma variável denominamos de meuXML do tipo XML, e nele acrescentamos exatamente um conteúdo qualquer de XML.
E na ultima linha do código AS utilizamos o método trace() para retornar o XML na caixa de saida(output).

Agora para conseguir ter acesso a um nó XML específico basta digitar após a variável (objeto XML) o operador ponto ( . ) seguido pelo "nome" do Nó XML que queremos encontrar. Como sabemos que o XML tem sua hierarquia de acesso e devemos respeitar isso. No Actionscript apenas separamos os "níveis" de cada Nó XML utilizando pontos( . ) seguido pelo nome do outro Nó interno.

Altere a ultima linha do código:

7

trace(meuXML);

Por:

7

trace(meuXML.linha);

Teste o filme(Ctrl + Enter). Como podemos ver, aparece agora o conteúdo que está inserido entre as tag <linha></linha>, que é o 1º e único Nó XML que temos no momento.
Se tivessemos outros Nó XML(níveis) inseridos entre a tags <linha></linha>, para acessar outras tags dentro desta, bastaria acrescentar pontos seguidos sempre pelo nome do Nó XML que queremos acessar e assim por diante. Vejamos este exemplo.

Altere o código que está:

1
2
3
4
5
6
7

var meuXML:XML = 
<meuXML>
	<linha>
		Conteudo
	</linha>
</meuXML>
trace(meuXML);

Altere por:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

var meuXML:XML = 
<meuXML>
    <linha1>
        <linha2>
            <linha3>
                <linha4>
                    <linha5>
                   		Conteudo da linha 5
                    </linha5>
                </linha4>
            </linha3>
        </linha2>
    </linha1>
</meuXML>
trace(meuXML.linha1.linha2.linha3.linha4.linha5);

Teste o Filme(Ctrl + Enter), neste exemplo acima apenas acrescentamos mais Nós XML, e para econtrar um Nó XML específico utilizo o nome de cada Nó separado por pontos. Isso fará eu acessar um determinado "nível" de um Nó específico que quero achar. No nosso exemplo retorna o conteudo que está na linha5.

3.1 - Pegando um atalho …

Até aí está bem. Mas se eu tivesse numa situação em que tenho um XML com uma quantidade maior de Nós? Chuta um número bem alto (exagerando: 100 Nós XML).
Teria que escrever um por um para chegar até o Elemento?
Depende da sua disposição pra isso.

Como assim?
Se preferir podemos digitar sim, nomes de cada Nó XML, um por um, separando os nomes por pontos conforme no exemplo anterior.
Ou podemos pular esse trabalho todo, ao invés de colocar apenas 1 ponto para separar os "níveis" de acesso a cada Nó, utilizamos 2 pontos seguidos (..) apenas uma vez, que podemos dizer que funciona como um "atalho".
Fazendo isso, irá "omitir" apenas os nomes dos Nós intermediários para chegar até onde queremos.
Para isso temos que inserir o 1º nome do Nó inicial e o último nome do Nó que queremos encontrar e inserir entre estes nomes os 2 pontos seguidos (..). Vejamos o exemplo a seguir.

Mantendo o mesmo código anterior, altere apenas ultima linha que está:

15

trace(meuXML.linha1.linha2.linha3.linha4.linha5);

Altere por:

15

trace(meuXML..linha5);

Teste o filme(ctrl+Enter). Você verá que o resultado é o mesmo que o código anterior. Mas acredito que 1º diferença é notável e unânime: Tivemos menos trabalho que o exemplo anterior. Não é?
Não importa a quantidade de Nós XML que foram inseridos um dentro do outro, se tiver 2 Nós ou mais Nós inseridos como "Níveis", este "atalho" (..) pode nos ajudar e muito a "poupar" tempo além de uma boa dor no pulso na hora de digitar. Exelente forma de "acesso rápido" em casos que temos grandes quantidades de Nós(Com diversos "níveis" de acesso).

Claro que esse atalho de 2 pontos seguidos(..) você irá decidir e perceber quando usá-lo conforme a sua necessidade.

3.2 - Acesso a Elementos de nomes iguais

Podemos trabalhar com XML que tenham 2 ou mais elementos(Nós XML)com mesmo nomes. Para ter acesso a cada um deles, utilizamos um tratamento parecido com um Array[].

Veja este exemplo. Apague o código do exemplo anterior e digite:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

var meuXML:XML = 
<meuXML>
    <time>
        <jogador>
            <posicao>
            	Fulano é goleiro
            </posicao>
        </jogador>
        <jogador>
            <posicao>
            	Beltrano é defensor
            </posicao>
        </jogador>
        <jogador>
            <posicao>
            	Ciclano é atacante
            </posicao>
        </jogador>
    </time>
</meuXML>
trace(meuXML.time.jogador[0].posicao);
trace(meuXML.time.jogador[1].posicao);
trace(meuXML.time.jogador[2].posicao);

Teste o filme(Ctrl + Enter), notamos que para ter acesso a um elemento específico, que tenha nomes idênticos para Nós XML, usamos o tratamento de "Array", onde inserimos "nomeDoElemento[ordem númerica]. A contagem sempre é a partir do 0(zero) em ordem crescente, que mostra que o número "zero"( ex.: jogador[0] ) é o 1º Nó XML do nível "time".

3.3 - Descobrindo a quantidade de Elementos

Em alguns casos em que temos muitos nós XML com mesmo nomes, conseguimos saber a quantidade de nós criados utilizando o método XML.length() da classe XML.

Acrescente uma nova linha neste código anterior e digite:

24

trace( meuXML.time.jogador.length() );

Teste o filme(ctrl + Enter), como podemos ver na caixa output, irá mostrar o conteúdo de cada jogador e mais a quantidade de números de tags que foram inseridas com o mesmo nome <jogador>. Que no nosso exemplo são 3 tag com nomes iguais .

3.4 - Usando Loop for each

Se você quer saber conteúdo de cada elemento que tenha o mesmo nome no arquivo XML. Podemos usar o loop for each que verifica cada nome de Elemento encontrado com nome que você precisa achar no XML mostrando seu respectivo conteudo de cada tag encontrada. Isto é util quando temos nomes de Tags XML com nome iguais e queremos ver o conteudo ao invés de apenas saber a quantidade de Nós com o método XML.length().

Vamos aproveitar o mesmo código anterior, apenas altere as 4 ultimas linhas:

21
22
23
24

trace(meuXML.time.jogador[0].posicao);
trace(meuXML.time.jogador[1].posicao);
trace(meuXML.time.jogador[2].posicao);
trace( meuXML.time.jogador.length() );

Por:

21
22
23

for each( var jogador:XML in meuXML.time.jogador){
	trace(jogador);
}

Teste o filme, verá que retorna o conteudo de cada Tag jogador que for encontrada no XML.
Neste loop criamos um variável com nome que determinamos como jogador(poderia ser qualquer nome) do tipo XML, e após o keyword in irá verificar no documento XML a cada Nò XML que preciso buscar ( meuXML.time.jogador ). Ou seja, enquanto tiver conteúdo específicado no loop irá fazer o que estiver entre as chaves { }. Que neste caso irá mostrar na caixa Output o conteúdo de cada Nó jogador encontrado no arquivo XML e irá agregar o valor econtrado à variável que criamos (jogador). Este loop só irá acabar quando econtrar todos os nós XML que foi especificado no loop for each.

3.5 - Encontrando Atributos de um Elemento

Para carregar um valor de um Atributo XML de qualquer Elemento específico, também buscamos por nomes assim como fazemos para buscar um Elemento XML. Mas, devemos acrescentar antes do nome do atributo o simbolo "@"(logo depois do ponto que separa um Elemento XML) indicando que esse Atributo pertence a um Elemento. Sendo esta sintaxe:
//retorna o valor do Atributo da Tag XML.
meuObjetoXML.nomeDaTagXML.@nomeDoAtributoDestaTagXML

Exemplo. Apague o código anterior e digite:

1
2
3
4
5

var meuXML:XML = 
<meuXML>
	<nome idade="10 anos" />
</meuXML>
trace(meuXML.nome.@idade);

Teste o filme, ira retornar na caixa Output apenas o valor do atributo(idade) da tag <nome>.

4 - Carregando XML externo

Para ler um arquivo XML externo, a principio é exatamente o mesmo conceito usado para ler um conteúdo de XML que foi gerado diretamente pelo Actionscript.
A diferença que precisamos
utilizar 3 Classes do AS3 para este exemplo. Sendo elas:
A Classe URLRequest(), URLLoader e finalmente a Classe XML();

- URLRequest(), é responsável por armazenar endereços externos. No nosso caso será um arquivo XML;
- URLLoader(), é responsável por "recuperar" dados/informações externas. A qual faremos um ouvinte para manipular com Eventos.
- XML(), para quando criarmos o Objeto XML e fazer referência a ele aos dados que estão no arquivo XML externo.

Crie um novo documento Flash na versão Actionscript 3.0 e salve com o nome "carregando_xml_externo.Fla". Clique na primeira Layer e dê o nome de "Actions".
Em seguida selecione o primeiro frame e abra o painel de Actions Window > Actions (atalho F9). Digite na 1º linha:

1
2
3
4

var meuURL:URLRequest = new URLRequest("casa.xml");
var infoXML:URLLoader = new URLLoader();
infoXML.load( meuURL );
infoXML.addEventListener( Event.COMPLETE, leiaXML );

Na 1º linha do código AS, criamos uma variável com nome de meuURL do tipo(:) URLRequest que faz parte da classe URLRequest(). O Parametro solicitado entre os parênteses ( ) desta classe é do tipo String, que necessita exatamente o endereço do arquivo externo que queremos trabalhar. Pode ser endereço relativo( minhaPasta/arquivo.xml ) ou endereço absoluto(http://…arquivo.xml).
No nosso caso um arquivo XML(casa.xml) e está na mesma pasta do nosso arquivo Flash.

Na 2º linha, criamos uma variável que denominamos de infoXML que é a partir da classe URLLoader(). Esta classe URLLoader solicita um objeto da classe URLrequest.

Na 3º linha, utilizamos o método URLLoader.load(). O Parâmetro solicitado neste método load() é o endereço do nosso arquivo externo, a variável meuURL.
Como sabemos esta variável meuURL contém a informação de um arquivo externo, o nosso XML(casa.xml).

Existe também uma outra maneira de declarar essa variável URLRequest é utilizar a propriedade URLRequest.url:

1
2

var meuURL:URLRequest = new URLRequest();
meuURL.url = "casa.xml";

Vamos trabalhar com a 1º opção de declaração da variável URLRequest.

Ainda se quiser também, podemos colocar apenas uma linha para criar a variavel URLLoader e acrescentar o endereço da classe URLRequest() dentro do parênteses ( ) da classe URLLoader().
Ex:

var infoXML:URLLoader = new URLLoader( new URLRequest("casa.xml") );

Mas caso você opte em fazer isso, não será necessário criar uma variável URLRequest e nem deverá declarar o método URLLoader.load() para fazer download do arquivo externo. Pois já está inserido o endereço entre os parênteses da Classe URLRequest( ).
Mas desta maneira, talvez você não terá tanto dinamismo no seu código. Pois, ao invés de você poder definir outros endereços externos para o URLLoader() alterando apenas a variavel do URLRequest(), você terá um endereço fixo sempre para este mesmo objeto URLLoader().

Vamos trabalhar com a 1º idéia proposta no código inicial. Isto foi apenas para mostrar outras maneiras de criação.

Retomando. Em nosso exemplo seu código deve estar da seguinte forma:

1
2
3
4

var meuURL:URLRequest = new URLRequest("casa.xml");
var infoXML:URLLoader = new URLLoader();
infoXML.load( meuURL );
infoXML.addEventListener( Event.COMPLETE, leiaXML );

Na 4º linha, adicionamos um Ouvinte de Eventos para a variável infoXML ( infoXML.addEventListener ) os parametros solicitados dentro dos parênteses ( ), são o tipo de Evento que quero quando for totalmente carregado ( Event.COMPLETE ) e a função que denominamos de leiaXML que será chamada/executada fazendo o que eu precisar com este arquivo externo.
Ou seja, em outras palavras, este Ouvinte (infoXML.addEventListener) é responsável por verificar quando for totalmente carregado este arquivo externo(casa.xml), e quando isso ocorrer com sucesso, irá executar uma função que iremos criar a seguir.

Na linha seguinte, digite:

5
6
7
8

function leiaXML( evento:Event ):void {
	var meuXML:XML = new XML( infoXML.data );
	trace( meuXML.Corredor[1].Quarto[2].Armario.Gaveta[1] );
}

Criamos a função com o nome de LeiaXML, e dentro do seu parênteses ( ) solicita um parâmetro de Evento que denominamos de evento do tipo(:)Event. Este “evento” contem as informações do arquivo externo. É uma regra no AS3 colocar esse parâmetro em funções dedicadas a Eventos. Isso porque podemos trabalhar com este “evento” para fazer referências de "alvos" como exemplo evento.target se precisar para alguma outra aplicação.
Em seguida, ainda dentro da chaves { } desta função LeiaXML,
Criamos uma variável com nome de meuXML do tipo(:) XML que é a partir da classe XML(). E o parâmetro que é solicitado entre os parênteses desta Classe XML( ) é a propriedade URLLoader.data. Que como sabemos é nossa variavel infoXML que contem informações dos dados do XML(casa.xml).A variavel meuXML é o Documento XML propriamente dito contendo todos seus Nós XML.

E por fim, na linha seguinte informamos o caminho da informação que quero buscar no Documento XML.
Neste caso, é um Nó XML que irá retornar a informação de texto na caixa de saída(Output) utilizando o método trace().
Mostrando assim, apenas o conteúdo do Nó XML que eu preciso no momento.

Se você acompanhou a Etapa 1 no final do capítulo 1.2 - Falando um pouco de Array.
Demos a sugestão de buscar a informação que era saber no XML em que lugar estava as "Minha Roupas".

meuXML.Corredor[1].Quarto[2].Armario[4].Gaveta[1];
Este caminho retorna o valor que eu preciso buscar em um Nó XML do arquivo casa.xml. O valor de texto: "Minhas Roupas".

Se desejar, podemos utilizar um "atalho" para esse caminho todo, que é muito útil em casos que temos quantidade grandes de "Níveis"(Nós XML) para acessar. Basta utilizar 2 pontos em sequencia para separar do Elemento Inicial até o Elemento final. Ficando da seguinte forma:
meuXML..Gaveta[1];
Obs.: no capítulo 3.1 - Pegando um atalho … explica como utilizar esse “atalho”.

Teste seu filme, Control > Test Movie (Ctrl + Enter).
Seu código todo deve ficou da seguinte maneira:
Obs.: O código completo está brevemente comentado em cada linha.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//criamos variaveis para URLrequest e URLLoader
var meuURL:URLRequest = new URLRequest("casa.xml");
var infoXML:URLLoader = new URLLoader();
 
/*fazemos o download do arquivo externo
pelo método URLLoader.load()*/
infoXML.load( meuURL );
 
/*adicionamos um ouvinte para o URLLoader
utilizamos o Evento de carregar por completo
e chamamos a função LeiaXML*/
infoXML.addEventListener( Event.COMPLETE, leiaXML );
 
//criamos a função que irá ler o XML
function leiaXML( evento:Event ):void {
    /*criamos o objeto XML contendo a informações
    do arquivo externo usando a propriedade URLLoader.data*/
    var meuXML:XML = new XML( infoXML.data );
 
    /*mostramos informações na caixa de saída(output)
    retorna o valor do Nó XML <Gaveta>: "Minhas Roupas"*/
    trace( meuXML.Corredor[1].Quarto[2].Armario.Gaveta[1] );
}

O resultado final deste exemplo deve ter ficado algo parecido como a Imagem 4 e Imagem 5 que estão logo a seguir:

Documento Flash:

Imagem 4: Codigo AS3, Carregando um arquivo XML externo e mostrando na caixa de saída(Output).

Documento XML:

Imagem 5: Documento XML casa.xml.

Utilizamos apenas o método trace() para dar maior foco no entendimento de leitura do XML.
Mas, se quiser aplicar estes valores XML em caixa de texto dinâmica. Basta cria-la no stage e dar um nome de uma instância para a mesma. E no lugar do trace() utilize a propriedade TextField.text ou TextField.htmlText para receber os valores do XML. O Flash Player interpreta o XML como dados de Texto assim como o HTML. Por isso, talvez você precise utilizar a propriedade TextField.htmlText caso tenha inserido textos no XML utilizando formatação apropriada de HTML.

Abraços e até a próxima!

Rodrigo Gonçalves
Equipe Alvo Web

O Conteúdo do Alvo Web Developers está licenciada sob uma Creative Commons Atribuição-Uso Não-Comercial-Compartilhamento pela mesma Licença 2.5 Brasil License.

Autor: Rodrigo Gonçalves

Package: flash.net
Classe: public class URLLoader
Versão AS: ActionScript 3.0
Player: Flash Player 9

Dificuldade: conhecimentos básicos de funcionamento do Flash, Actionscript 3.0 e lógica de programação.

Fala Galera, tranquilo?!

Vamos ver como carregar variáveis com AS3.
Mas antes é interessante sabermos como o Flash trabalha leitura de dados no AS3. Caso você já tenha conhecimentos sobre variáveis, sinta-se a vontade para pular a introdução.

Introdução

Quando o Flash carrega dados de uma URL, o Flash Player pode interpretar de três formas, sendo elas:

- Texto: como exemplo HTML e XML;
- Binário;
- Variáveis: conhecido também como URL-encoded variables.

Veremos sobre variáveis, e precisamos seguir algumas regras mais importantes para criação de variáveis:

* Cada nome de variável tem que ser associada com um valor sempre usando o sinal de igual (=) sem espaços entre eles.
Não podemos confundir com sinal de equivalência (==), que serve para comparação entre dois valores, e não para associação de um valor para variável;
Ficando algo do tipo: minhaVariavel=meuValor. Quer dizer que minhaVariavel recebe(=) meuValor como conteúdo.

* Os valores das variáveis são tratadas como tipo Strings no Flash. Sendo assim, não precisamos inserir aspas duplas " " ou aspas simples ‘ ‘ em seus valores;

* Se existir mais de um par de variáveis/valores que queira acrescentar no arquivo, devemos separar utilizando o sinal (&). Exemplo:
variavel1=valor1&variavel2=valor2&variavel3=valor3

* Para representar os espaços quando digitamos a tecla "espaço". Para uma melhor compatibilidade de leitura, podemos também utilizar o sinal de adição (+). Exemplo:
variavel=Aqui+carregamos+valores
Isto quando o Flash lê esta variavel reconhece o sinais(+) inseridos no valor como se tivesse digitado o "espaço" no teclado, mostrando da seguinte maneira:
Aqui carregamos valores.

Podemos também utilizar o espaço normal. Exemplo
variavel=Aqui carregamos valores

Ou ainda caracteres como (%20) que representa o "espaço". Exemplo:
variavel=Aqui%20carregamos%20valores

Com isso já sabemos o principal e essencial que o Flash precisa para podermos formatar os dados carregados e fazer com que o Flash faça a leitura corretamente.

Na versão AS3, não utilizamos mais a classe LoadVars para carregar ou enviar dados como faziamos na versão anterior do Actionscript. Passamos agora, a utilizar a classe URLLoader().
Esta classe também pode trabalhar em "conjunto" com algumas outras classes, como Ex.:
URLRequest(), URLVariables(), URLStream, Loader(), entre algumas outras classes.

- URLLoader(), é responsável por "recuperar" dados/informações externas no Flash;
- URLRequest(), é responsável por armazenar endereços externos;
- URLVariables(), é utilizado para criarmos variáveis dentro do Flash para comunicar com um scripts (ex: PHP, ASP) quando queremos fazer formulários de envio de e-mail ou buscas;
- URLStream(), é utilizado para fluxo de dados. Mas é aconselhável utilizar esta classe somente em casos que o arquivo é "muito grande" e a URLLoader() não é suficiente. Por exemplo, podemos dizer que esta classe URLStream() verifica os dados que já foram carregados e mostra no filme conforme esteja disponível ou para verificar o progresso de download do arquivo.
- Loader(), é responsável por carregar arquivos externos, como imagens(.jpg, .gif, .png, filmes SWF´s).

Carregando variáveis com AS3:

Primeiro precisamo criar nosso arquivo Txt contento como formato variável=valor. Abra um "bloco de notas" ou seu editor de códigos e salve como "arquivo.txt".
Dentro deste arquivo, digite 3 variáveis seguidos do seus respectivos valores:

Obs.: Você pode criar suas próprias variáveis e valores que desejar. Neste exemplo criamos:

site=Alvo+Web&categoria=Actionscript+3.0&comentario=carregar+variáveis+no+AS3

Imagem 1: Criando nosso arquivo Txt.

Tendo nosso arquivo .Txt criado, vamos ao Actionscript.

Precisamos inicialmente utilizar duas classes, sendo elas:
- URLRequest() é responsável por armazenar endereços externos. No nosso caso será um "arquivo.txt";
- URLLoader() é responsável por "recuperar" dados/informações externas.

Crie um novo documento .Fla na versão Actionscript 3.0.
Na primeira camada, selecionando o primeiro frame abra o painel de Window>Actions (atalho F9).

Digite:

1
2
3
4
5

var url:URLRequest = new URLRequest( "arquivo.txt" );
var infoTxt:URLLoader = new URLLoader();
infoTxt.dataFormat = URLLoaderDataFormat.VARIABLES;
infoTxt.load(url);
infoTxt.addEventListener( Event.COMPLETE, leiaArquivoTxt );

Na primeira linha, criamos a variável com nome url para a classe URLRequest(), nela iremos armazenar o endereço do nosso arquivo.txt.
o endereço pode ser relativo (ex.: pasta/meuArquivo.txt) ou absoluto (ex.: http://www…/pasta/meuArquivo.txt). Neste exemplo estamos trabalhando na mesma pasta do arquivo .Fla.

Na segunda linha, criamos uma variável com nome de infoTxt para a classe URLLoader(), que servirá para recuperar informações/dados externos que estão no nosso arquivo.txt.

Na terceira linha, utilizamos a propriedade URLLoader.dataFormat que serve para formatar as informações/dados externos, e "dizer" ao Flash qual tipo de arquivo ele irá interpretar. Se é um tipo: Texto, Binário ou Variável.
No nosso caso queremos ler variável, então definimos como URLLoaderDataFormat.VARIABLES. Quando definimos a propriedade dataFormat para o valor de DataFormat.VARIABLES, a propriedade data(que veremos mais a diante) irá ter um comportamento de um Objeto(Object), que irá "mapear" os nomes de variáveis com seus respectivos valores do arquivo que estamos carregando.
Por padrão o Flash Player interpreta dados externos como Texto ( URLLoaderDataFormat.TEXT ) que são considerados como uma "String"(textos). Por este motivo, precisamos formatar os dados para encontrar e ler Variáveis ( URLLoaderDataFormat.VARIABLES ).
O Flash irá "buscar" por variáveis que estiverem no arquivo informado no endereço que definimos pela classe URLRequest().

Na quarta linha, utilizamos o método/função URLLoader.load() que irá fazer o "download" do arquivo. Entre seus parenteses o parâmetro solicitado é URLRequest(). Como já definimos o endereço pela variável url, apenas inserimos seu nome de variável url entre seus parenteses do método load().

Na quinta linha, adicionamos um ouvinte ( addEventListener ) para a variável infoTxt da URLLoader(), que irá verificar pelo Evento quando for carregado por completo ( Event.COMPLETE ), chama uma função que denominamos de leiaArquivoTxt. Esta função será responsável por ler as variáveis que definimos no arquivo.txt. Iremos criar está função a seguir:

Numa próxima linha digite:

6
7
8

function leiaArquivoTxt( evento:Event ):void{
	trace( infoTxt.data );
}

Teste o filme, (Ctrl+Enter). Você verá na caixa de saida/output que irá aparecer exatamente todo o arquivo.txt com suas variáveis e respectivos valores. Assim como na imagem 2 logo abaixo.

Imagem 2: lendo arquivo txt mostrado na caixa de saída (output) do Flash CS3.

Criamos a função leiaArquivoTxt que só é acionada/executada quando o arquivo.txt for totalmente carregado pelo evento descrito no ouvinte que definimos logo acima. Entre seus parenteses denominamos um parâmetro com nome evento do tipo Event ( evento:Event )Entre suas chaves digitamos o método trace() dentro deste método trace definimos a propriedade URLLoader.data, que como sabemos é nossa variável infoTxt.data que recebe todos os dados/informações daquele arquivo que foi carregado (arquivo.txt).

Agora, caso queira ler uma variável específica, basta informar como propriedade de URLLoader.data exatamente o nome da variável que está dentro do arquivo.txt.
Tendo está sintaxe:

URLLoader.data.variavel

Em nosso arquivo definimos três variáveis:
site
categoria
comentario

Então podemos podemos escrever da seguinte forma:

Ainda dentro da função leiaArquivoTxt, apague a linha 7:

7

trace( infoTxt.data );

Altere por:

7
8
9

trace( infoTxt.data.site );
trace( infoTxt.data.categoria );
trace( infoTxt.data.comentario );

Teste o filme, (Ctrl+Enter). Você verá agora na caixa de saida (output) que irá aparecer exatamente o valor referente a cada variável que definimos no arquivo.txt.

Seu código todo deve ter ficado da seguinte maneira:

1
2
3
4
5
6
7
8
9
10

var url:URLRequest = new URLRequest( "arquivo.txt" );
var infoTxt:URLLoader = new URLLoader();
infoTxt.dataFormat = URLLoaderDataFormat.VARIABLES;
infoTxt.load(url);
infoTxt.addEventListener( Event.COMPLETE, leiaArquivoTxt );
function leiaArquivoTxt( evento:Event ):void {
	trace( infoTxt.data.site );
	trace( infoTxt.data.categoria );
	trace( infoTxt.data.comentario );
}

Imagem 3: carregando variáveis no Flash CS3 utilizando AS3.

for …in

Muitas vezes você já saberá os nomes das variaveis que deseja ler assim como nesse exemplo acima que você acompanhou. Porém, em alguns casos podemos trabalhar com arquivos feitos por outros programadores e precisamos saber das variáveis para ler o mesmo no Flash.
Existe um meio bastante interessante e útil que inúmera todas a variáveis existentes no arquivo que foi carregado. Para isto utiilzamos o loop for …in

veja um exemplo.
Imagine que você ainda não sabe todas as variaveis existentes no arquivo que criamos (arquivo.txt).
Aproveitando este mesmo exemplo do arquivo .Fla e arquivo.txt, vamos recuperar todos os nomes das variáveis seguido dos seus respectivos valores.

Ainda dentro da função leiaArquivoTxt, apague as linhas: 7, 8 e 9:

7
8
9

trace( infoTxt.data.site );
trace( infoTxt.data.categoria );
trace( infoTxt.data.comentario );

e Digite no lugar:

7
8
9

for( var propriedade:String in infoTxt.data ){
	trace( propriedade + " = " + infoTxt.data[propriedade] );
}

Dentro da Função leiaArquivoTxt, criamos o loop for…in.
Todas as variáveis do arquivo Txt é armazenada na variável que denominamos de propriedade do tipo String.
E a cada vez que isso ocorre. Ou seja, cada vez que a propriedade procura os dados do arquivo.txt ( infoTxt.data ), executa o que estiver dentro da sua chaves { }. Este loop só termina quando recuprar todas as variáveis do arquivo.

Dentro da sua chaves { }, utilizamos o método trace() para mostrar o resultado na caixa de saída.
Como sabemos que a variável propriedade recebe o nome de cada variável do arquivo.txt, podemos utilizar uma espécie de Array [ ] para achar os valores de cada variável, e dentro da [ ] colocamos o nome da variavel propriedade que definimos, ficando assim:
infoTxt.data[ propriedade ]

Com isso você consegue recuperar os valores na caixa output:
sintaxe: variavel = valor

Imagem 4: declaração de loop for… in. para recuperar variaveis/valores de um arquivo.

Caixa de texto Dinâmico

Se você quer aplicar os valores das variáveis à uma caixa de texto dinâmica (ex.: TextField). Basta fazer da seguinte forma.
Suponhamos que neste caso você já tenha criado três caixas de texto dinâmico, e inseridos os mesmo no stage (palco) com seus nomes de instâncias denominadas como: campo1, campo2 e campo3.

No lugar do método trace() você pode utilizar a propriedade TextField.text:

7
8
9

campo1.text = infoTxt.data.site;
campo2.text = infoTxt.data.categoria;
campo3.text = infoTxt.data.comentario;

Imagem 5: recuperando valores e mostrando em uma caixa de texto dinâmico.

Abraços e até a próxima!

Rodrigo Gonçalves
Equipe Alvo Web

O Conteúdo do Alvo Web Developers está licenciada sob uma Creative Commons Atribuição-Uso Não-Comercial-Compartilhamento pela mesma Licença 2.5 Brasil License.