ActionScript 3.0 Orientado A Objeto

[Michel Araújo 0]

ActionScript 3.0 Orientado a Objetos

Aula 03: Sintaxe do ActionScript - Controle de Fluxo

Muitas vezes em um programa, você desejará repetir determinadas ações, executar apenas algumas e outras não, executar ações conforme condições específicas etc. O controle de fluxo é o controle sobre as ações que são executadas.

O bloco de instruções a ser executada dentro de um elemento de controle de fluxo é delimitado por chaves {} (embora em alguns casos seja opcional, é uma boa prática SEMPRE utiliza-las. Será o padrão que utilizaremos).

A seguir veremos os principais elementos para controle de fluxo no ActionScript 3.0:


Estruturas Condicionais:

As Estruturas Condicionais fornecem um meio de executar algumas instruções somente sob determinadas circunstâncias ou de fornecer conjuntos alternativos de instruções para condições diferentes.
As Estruturas condicionais não possuem escopo próprio, ou seja, objetos criados dentro delas podem ser acessados fora de seu bloco de instruções (desde que o bloco onde estão tenha sido executado)

São elas:

if...else

A instrução condicional if..else permite testar uma condição e executar um bloco de código se essa condição for verdadeira, ou executar um bloco de código alternativo se não for verdadeira (ou seja, falsa).

Sintaxe:

 if(condição)
 {
 	// Bloco de Instruções a serem executadas
 	// caso a condição retorne VERDADEIRO (true)
 }
 else
 {
 	// Bloco de Instruções a serem executadas
 	// caso a condição retorne FALSO (false)
 }

Na condição do if você pode usar expressões com operadores relacionais e lógicos, além de poder testar o valor de uma variável booleana, se seu valor é true ou false.

Exemplo:

O seguinte código testa se o valor da variavel x é maior que 20, e executa uma função trace() imprimindo o resultado de acordo com o resultado:

 if (x > 20) //'se x for maior que 20...'
 {
 	trace("x é maior que 20");
 }
 	else //'se não...'
 {
 	trace("x é menor, ou igual a 20");
 }

Apenas um dos dois blocos de código será executado, dependendo do valor de x.
Se não quiser executar um bloco de código alternativo, você poderá usar a instrução if sem a instrução else.

if..else if

É possível testar mais de uma condição usando a instrução condicional if..else if. Por exemplo, o código a seguir não apenas testa se o valor x excede 20, mas também se o valor x é negativo:

 if (x > 20)
 {
 trace("x é maior que 20");
 }
 else if (x < 0)
 {
 trace("x é menor que 20");
 trace("x é negativo");
 }

Dentro das chaves podem ser colocadas quantas instruções forem necessárias. Veja que nesse exemplo seriam executadas duas instruções, no caso de x representar um valor negativo.

switch

A instrução switch será útil se você tiver vários caminhos de execução que dependam da mesma expressão de condição. Ela fornece uma funcionalidade semelhante a uma longa série de instruções if..else if, mas é mais fácil de ler. Em vez de testar uma condição quanto a um valor booleano, a instrução switch avalia uma expressão e usa o resultado para determinar qual bloco de código será executado. Os blocos de código começam com uma instrução case e terminam com uma instrução break.

Sintaxe:

 switch(valor a ser testado)
 {
 	case valor1:
 	 // Bloco de instruções se o valor sendo testado
 	 // for valor1
 	 break;
 	case valor1:
 			// Bloco de instruções se o valor sendo testado
 			// for valor2
 			break;
 	default:
 			// Bloco de instruções se o valor sendo testado
 			// não for igual a nenhum dos valores anteriores
 			break;
 }

O uso do default é opcional, e deverá ser sempre a última opção da lista. O uso do break dentro do bloco de instruções do default também é opcional.

Exemplo:

A seguinte instrução switch imprime o dia da semana, com base no número de dias retornado pelo método Date.getDay():

 /* Pegamos a data atual utilizando a classe Date e atraves do metodo getDay() 
 obtemos um valor numerico, que indica o dia da semana sendo:
 	0: Domingo;
 	1: Segunda-Feira;
 	2: Terça-Feira;
 	... e consecutivamente
 */
 var dataDeHoje:Date = new Date();
 var dia:uint = dataDeHoje.getDay();
 
 switch(dia)
 {
 	case 0:
 		trace("Hoje é Domingo");
 		break;
 	case 1:
 		trace("Hoje é Segunda");
 		break;
 	case 2:
 		trace("Hoje é Terça");
 		break;
 	case 3:
 		trace("Hoje é Quarta");
 		break;
 	case 4:
 		trace("Hoje é Quinta");
 		break;
 	case 5:
 		trace("Hoje é Sexta");
 		break;
 	case 6:
 		trace("Hoje é Sábado");
 		break;
 	default:
 		trace("Houve algum erro. Não sei que dia é hoje.");
 		break;
 }

Estruturas de Repetição (loop):

As Estruturas de Repetição permitem designar um conjunto de instruções que o computador executará por um determinado número de vezes ou até que alguma condição seja alterada. Com freqüência, os loops são usados para manipular vários itens relacionados, empregando uma variável cujo valor é alterado sempre que o computador completa o loop.

As Estruturas de Repetição também não possuem escopo próprio, ou seja, objetos criados dentro delas podem ser acessados fora de seu bloco de instruções.

São elas:


for

A repetição for permite fazer a iteração por meio de uma variável para um intervalo específico de valores. Você deve fornecer três expressões em uma instrução for: uma variável que é definida com um valor inicial (inicialização), uma instrução condicional que determina quando a repetição termina (condição) e uma expressão que altera o valor da variável a cada repetição (atualização).

Sintaxe:

 for (inicializaçao; condição; atualização) 
 {
 	//Bloco de intruções a ser executado
 }

Exemplo:

O exemplo a seguir imprime os valores de 0 à 10 (o bloco de código é executado 11 vezes).

 var i:int;
 for (i = 0; i <= 10; i++)
 {
 	trace(i);
 }

for..in

A repetição for..in itera por meio das propriedades de um objeto ou dos elementos de uma matriz.

Sintaxe:

 	for(Propriedade in Objeto)
 	{
 		//Bloco de intruções a ser executado
 	}

Exemplo:

 var meuObjeto:Object = {x:20, y:30};
 for (var propriedade:String in meuObjeto)
 {
 	trace(propriedade + ": " + meuObjeto[propriedade]);
 }

Neste exemplo ele irá repetir o bloco de instruções de acordo com o numero de propriedades do meuObjeto (no caso, duas, x e y), e a cada repetição o valor da variavel propriedade corresponde à uma determinada propriedade do objeto.

As propriedades de objeto não são mantidas em uma ordem específica, por isso elas podem aparecer em uma ordem aparentemente aleatória.

for each..in

A repetição for each..in itera por meio dos itens de um conjunto, que podem ser tags em um objeto XML ou XMLList, os valores mantidos pelas propriedades do objeto ou os elementos de uma matriz. Você pode usar uma repetição for each..in para iterar por meio das propriedades de um objeto genérico, mas diferentemente da repetição for..in, a variável do iterador em uma repetição for each..in contém o valor mantido pela propriedade em vez do nome da propriedade.

Sintaxe:

 	for each (Valor in Objeto)
 	{
 		//Bloco de intruções a ser executado
 	}

Exemplo:

Você pode iterar por meio de um objeto XML ou XMLList, como mostra o seguinte exemplo:

 var listaAlunos:XML = <alunos>
 						<nome>Rick</nome>
 						<nome>Elektra</nome>
 						<nome>lordofthedreams</nome>
 					</alunos>;
 for each (var nomeAluno in listaAlunos.nome)
 {
 	trace(nomeAluno);
 }

//Saida:
Rick
Elektra
lordofthedreams

while

A repetição while é como uma instrução if que é repetida desde que a condição seja true.

Sintaxe:

 while(condicao)
 {
 	//Bloco de intruções a ser executado
 	//Deve haver uma instrução que mude o valor testado na condição
 }

Perceba que ao contrário do for, o while não possui a condição para repetição como parametro. A mudança no valor da condição deve ser feita dentro do bloco de códigos. Isso torna mais fácil a criação de loops infinitos, portanto, cuidado.

Exemplo:

Esse código também imprime os valores de 0 à 10:

 	var i:int = 0;
 	while (i <= 10)
 	{
 		trace(i);
 		i++;
 	}

do..while

A repetição do..while é uma repetição while que garante que o bloco de código seja executado pelo menos uma vez, porque a condição é verificada depois que o bloco é executado.

Sintaxe:

 do
 {
 	//Bloco de intruções a ser executado
 	//Deve haver uma instrução que mude o valor testado na condição
 } while (condicao);

Funções:

As funções são blocos de código que executam tarefas específicas e podem ser reutilizados no seu programa. Há dois tipos de funções no ActionScript 3.0: métodos e fechamentos de função. O fato de uma função ser uma chamada a um método ou um fechamento de função depende do contexto na qual ela é definida. Uma função é chamada de método quando é especificada como parte de uma definição de classe ou anexada a uma ocorrência de um objeto. Uma função é chamada de fechamento de função quando é definida de qualquer outra forma.

As funções possuem escopo próprio, ou seja, objetos declarados dentro da função só podem ser acessados dentro dela.

Sintaxe para Criar uma Função:

 function nomeDaFuncao(parametros Da Funcao):Tipo
 {
 	//Bloco de intruções a ser executado
 }	

Uma outra forma de criar uma função é apontando uma variável do tipo Function para uma instancia da classe Function. Trata-se de um método menos usual, que não será utilizado nem discutido aqui

O uso de parâmetros para função é opcional, bem como o tipo de dados a ser retornado (nesse caso será considerado void, ou seja nada).

Sintaxe para Chamar uma Função:

Uma função é chamada usando seu nome seguido de um operador parênteses (()). Dentro dos parênteses podem ser incluidos parametros (necessários ou não) à função. Se estiver chamando uma função sem nenhum parâmetro, você deverá usar parênteses vazios.

nomeDaFuncao(parâmetros);

Parametros da Função:

Os parâmetros são valores passados à função, que ficam disponíveis na função como variáveis locais.

O nome e tipo de dado dos parâmetros são declarados na definição da função. Quando houver mais de um parâmetro, devem ser separados por virgula, seguindo a sintaxe:

 function minhaFuncao(parametro1:Number, parametro2:String, parametro3:Array):void
 {
 	// Bloco de instruções a ser executado.
 	// Aqui serão usados os valores passados pelos parametros
 	// Usando a nomeclatura definida, ou seja, parametro1, parametro2 e parametro3
 }

Atenção:
Os valores passados como parâmetros de uma função no ActionScript 3.0 são transmitidos por referência. Isso significa que ao alterar o valor do argumento dentro da função, altera também o objeto que foi passado.
Porém, para objetos de tipo de dados primitivos (Number, String, etc), têm operadores especiais que fazem com que se comportem como se fossem transmitidos por valor, ou seja, sua modificação dentro da função não implica em modificação no objeto original passado como argumento.
Para mais detalhes, consulte a documentação do ActionScript 3.0.

Valores de parâmetro padrão:

Se uma chamada a uma função com valores de parâmetro padrão omitir um parâmetro com valores padrão, será usado o valor especificado na definição de função para esse parâmetro. Todos os parâmetros com valores padrão devem ser colocados no final da lista de parâmetros. Os valores atribuídos como padrão devem ser constantes de tempo de compilação. A existência de um valor padrão para um parâmetro efetivamente o torna um parâmetro opcional. Um parâmetro sem um valor padrão é considerado um parâmetro necessário.

Para definir um valor padrão a um parâmetro, basta atribui-lo na definição da função:

 function minhaFuncao(parametro:String = "Valor Padrão do Parametro"):void
 {
 	trace(parametro);
 }
 
 //Agora eu chamo a função:
 //Aqui, o trace vai imprimir "Valor Padrão do Parametro",
 //pois o valor não foi passado, e ficará o padrão
 minhaFuncao();
 //Aqui, o trace vai imprimir "Valor Definido para o parametro",
 //que foi o valor passado como parametro
 minhaFuncao("Valor Definido para o parametro")

Retorno de valores de funções:

Para retornar um valor de sua função, use a instrução return seguida pela expressão ou pelo valor literal que deseja retornar. Observe que o valor retornado deve ser compatível com o tipo de dados que a função retorna, definido na criação da função.

Observe também que a instrução return encerra a função, de forma que as instruções abaixo de uma instrução return não são executadas.

Veja um exemplo:

 function soma(nro1:Number, nro2:Number):Number{
 	return (nro1 + nro2);
 }
 //Irá imprimir na tela o valor resultante da soma feita na função.
 //Veja que o tipo retornado na função é compativel com o declarado.
 trace(soma(10, 15));

Veja mais:

Alguns detalhes sobre funções fogem dos objetivos dessa parte do curso, que é apresentar o básico da sintaxe do ActionScript 3.0. Porém, fica a sugestão de pesquisa sobre:

• Passando funções como objeto;
• O objeto arguments;
• O parâmetro ... (rest)

Pessoal o feedback de vocês é de extrema importância.

Referências:

Documentação Adobe

[Matheus Brito 12]

Show de bola.

Abs

 

p.s tá otima a formatação

[lordofthedreams 0]

Eu vou te bombardear de dúvidas! rs

 

 

 var meuObjeto:Object = {x:20, y:30};
 for (var propriedade:String in meuObjeto)
 {
 	trace(propriedade + ": " + meuObjeto[propriedade]);
 }

No caso do for..in, foi declarado a variável meuObjeto, que se mostra igual uma classe ou tipo Object (:Object), é isso?

A variável é igual a {x:20, y:30}. Isso é uma cordenada cartesiana mesmo?

Aí eu me confundi. Foi declarada a variável propriedade, que é uma String(então texto) do meuObjeto. Onde esta variável está ligada? Seria nos valoes cartesianos?

 

 

var listaAlunos:XML = <alunos>
 						<nome>Rick</nome>
 						<nome>Elektra</nome>
 						<nome>lordofthedreams</nome>
 					</alunos>;
 for each (var nomeAluno in listaAlunos.nome)
 {
 	trace(nomeAluno);
 }

Aqui eu entendi bem, e achei muito bom. Por curiosidade futura, há como usar arquivos externos em xml, importá-los e alterá-los dentro interativamente? Algo como salvar nomes de jogadores e recordes. Só curiosidade.

[Michel Araújo 0]

vamos lá, por partes:

 

No caso do for..in, foi declarado a variável meuObjeto, que se mostra igual uma classe ou tipo Object (:Object), é isso?

Sim, é uma variável do tipo Object.

 

A variável é igual a {x:20, y:30}. Isso é uma cordenada cartesiana mesmo?

Sim, pode ser coordenadas cartesianas. Mas assim como coloquei x e y, poderia ter posto qualquer coisa. A classe Object (que é o tipo de dados da variável) é dinamica (camos ver mais pra frente), isso quer dizer que eu posso criar propriedades para ela. É como seu eu criasse 'variáveis' dentro da variável, ou do objeto mais especificamente. Exemplo:

 

var meuObjeto:Object = {largura:10, altura:20, peso:5};

veja que meuObjeto, possui suas proprias caracteristicas (que podemos chamar de propriedades, ou variáveis).

 

Foi declarada a variável propriedade, que é uma String(então texto) do meuObjeto. Onde esta variável está ligada? Seria nos valoes cartesianos?

a variável propriedade vai ser relacionada a cada 'propriedade' declarada do meuObjeto, e não ao seu valor. Ou seja, o for vai ser executado de acordo com o numero de propriedades existentes no objeto, e a cada loop, a variável propriedade vai ter um valor diferente. No exemplo que dei agora, a variável propriedade vai ter os valores:

 

'largura'

'altura'

'peso'

 

a cada vez que o loop passar, um valor diferente, não necessariamente nessa ordem.

 

Aqui eu entendi bem, e achei muito bom. Por curiosidade futura, há como usar arquivos externos em xml, importá-los e alterá-los dentro interativamente? Algo como salvar nomes de jogadores e recordes. Só curiosidade.

Sim, tem como importá-los, e alterar o valor da variável XML onde você colocou o conteúdo importado.

 

Já pra salvar o arquivo no host, você vai precisar de uma linguagem server-side.

 

[]'s, espero que tenha ajudado

[lordofthedreams 0]

Entendi melhor. Então podemos declarar propriedades a uma classe (no caso Object) e alterá-las ou reutilizá-las posteriormente?

 

Ex:

var minhaBola:Object = {raio:5, peso:20};
trace (minhaBola[raio])

isso retornaria o valor 5?

[Michel Araújo 0]

quase isso. Para usar a sintaxe com as chaves, o indice deve ser uma string (ou uma variável contendo uma string).

 

Esse é o motivo da variável 'propriedades' ter sido declarada como string. No seu caso:

 

var minhaBola:Object = {raio:5, peso:20};

trace(minhaBola[raio]); //Assim não funciona
trace(minhaBola['raio']); //Assim funciona

//Uma forma alternativa para o acesso assim, direto seria:
trace(minhaBola.raio);

[lordofthedreams 0]

Só uma curiosidade. Neste caso:

var minhaBola:Object = {raio:5, peso:20};
trace(minhaBola['raio']);

O trace interpretará o valor do raio, no caso 5? Nao sairá a palavra raio, por ser uma String?

 

//Para o acesso assim, direto seria:
trace(minhaBola.raio);

Pelo que já havia entendido, toda vez que se separa com um ponto a gente identifica uma propriedade do objeto. Muito bom!

[Michel Araújo 0]

é, a string 'raio' no caso é o 'indice' das prorpiedades do objeto. Da mesma forma como se faz em um array, por exemplo, usando indice numérico.

 

o trace vai retornar o valor da propriedade (no caso, 5).

 

Veja no exemplo do post inicial o trace que coloquei:

 

var meuObjeto:Object = {x:20, y:30};
for (var propriedade:String in meuObjeto)
{
	trace(propriedade + ": " + meuObjeto[propriedade]);
}

no trace eu concatenei a variável propriedade, que é uma string, com uma string literal contendo ': ' e acessei o valor da propriedade usando a variável como indice meuObjeto[propriedade].

 

Isso, nesse caso imprimiria algo assim:

 

x: 20

y: 30

...

//Ou seja

variavel: valor

 

[lordofthedreams 0]

Deixa eu ver se entendi.

 

var meuObjeto:Object = {x:20, y:30};// declarada a variável e suas propriedades
for (var propriedade:String in meuObjeto)//para a variável propriedade, foi pego um array como String (dados x e y) 
{
        trace(propriedade + ": " + meuObjeto[propriedade]);
}

Então no caso a variável propriedade tem os valores x e y, e a variável meuObjeto[propriedade] tem os valores de x e y, no caso 20 e 30.

 

 

Poderiamos então dar um trace direto nestas proprieades, como:

trace ("A altura do meu Objeto é:" + meuObjeto.y)

[Michel Araújo 0]

é isso =) Nesse caso, a variável propriedade terá os valores x OU y, um de cada vez. O for será executado 2x (pq o objeto possui 2 propriedades declaradas).

 

Poderiamos então dar um trace direto nestas proprieades, como:

trace ("A altura do meu Objeto é:" + meuObjeto.y)

sim =)

[lordofthedreams 0]

Pra mim fechou! Agora é botar em prática. E aguardar a quarta aula.

[Elektra 102]

Até o switch foi tranquilo, eu já tinha estudado no DVD do Erick Souza.

 

Questiono quanto a testar a condição de valores booleanos, pelo que aprendi é possível. Vale saber se existe outros meios mais recomendáveis.

 

Mas o exemplo do for não tem a clareza necessária para quem desconhece a sintaxe. Não fui além.

 

Li as postagens do lordofthedreams e me abstive em prosseguir.

 

Também senti falta dos operadores condicionais "?" e ":" na estrutura if. Conhecer o uso trouxe possibilidades sobre movie clips com buttonMode = true ativado. Ainda não sei alterar a cor, mas no exercício que fiz com alpha me deu idéia do funcionamento.

 

Vou prosseguir assistindo meu DVD com vídeo aulas, na medida da necessidade, posto minhas dúvidas.

 

Abraços

[Matheus Brito 12]

Na verdade o curso não daá pra abranger tudo, o if que você deseja é um if ternário que usa o ? e o :.

Porque o objetivo do curso é ensinar o básico mas o if ternário é nessa form:

 

function test():int{
 var x:int = t == 0 ? 10 : 20;
 return x;
}

ou 

if(t==0)
x = 10;
else
x = 20;

E so lembrando o curso é de orientacao a objetos, no que depender de mim, todos os exemplos que voces verão serão todos debugados no trace.

Abs

[Elektra 102]

Sim, eu li sobre a abordagem básica do curso.

Mesmo assim, penso que seja adequado considerar a facilidade de compreensão dos exemplos.

 

Este me parece bem mais claro:

 

mcbola.addEventListener(MouseEvent.CLICK, onclick);
var nome:String = "Pedro"

function onclick(evt:MouseEvent):void
{
        evt.target.alpha == 1 ? evt.target.alpha = .5 : evt.target.alpha = 1;
        trace(nome);
}
mcbola.buttonMode = true

Já este ficou obscuro:

 

 var meuObjeto:Object = {x:20, y:30};
 for (var propriedade:String in meuObjeto)
 {
        trace(propriedade + ": " + meuObjeto[propriedade]);
 }

 

Neste exemplo ele irá repetir o bloco de instruções de acordo com o numero de propriedades do meuObjeto (no caso, duas, x e y), e a cada repetição o valor da variavel propriedade corresponde à uma determinada propriedade do objeto.

 

As propriedades de objeto não são mantidas em uma ordem específica, por isso elas podem aparecer em uma ordem aparentemente aleatória.

 

[Michel Araújo 0]

é através dos comentários que posso (podemos, creio que o kisuke concorde) melhorar tanto na qualidade quanto na clareza do que estamos tentando fazer. Por isso é importante não se abster em comentar se sentir vontade e necessidade.

 

Quanto a ausência do operador ternário, tem um motivo: Ele pode ser prático, mas nem de longe é claro e de fácil leitura, e seu uso não oferece nenhuma vantagem quanto ao if...else.

 

Mesmo entre programadores experientes, o condicional ternário é muitas vezes evitado. Tudo pra tornar o código de leitura mais fluida, não para o compilador (que não faz diferença), mas para outros programadores.

 

No mais é isso =) Acho que as dúvidas são tão importantes quanto aos posts principais, por isso todos os comentários são bem vindos =)

 

[]'s

[Elektra 102]

Simplificando:

 

mc_bola.addEventListener(MouseEvent.CLICK, onClick);
var nome:String = "Pedro";

function onClick(evt:MouseEvent):void
{
	//nome = (nome == "Pedro") ? "Nino" : "Pedro";
	//trace(nome);
	evt.target.alpha = (evt.target.alpha == 1) ?  .5 : 1;
}

mc_bola.buttonMode = true;

Solicitei ao Matias Resende a edição do post anterior que continha um exemplo duplicado por engano.

 

Esta é a grafia mais adequada, para ser usado em casos mais simples como a propriedade alpha.

[walterDFF 0]

PERFEITO MICHEL.. tu tah quase ganhando uma comunidade no orkut kkkkk.. sério a iniciativa de escrever aulas são para poucos ainda mais se tratando de actionscript 3 ..então meus parabéns.. sobre o operador ternário realmente não tem tanta importância pelo menos agora.. e vamos pra frente, próxima aula!

[Michel Araújo 0]

obrigado walter, que bom que está gostando =)

 

próximos posts em breve ^_^

[Anderson Ronilson Xavier 0]

Michel e Kisuke, para mim vcs estaum de parabens.......as aulas estaum bem claras e objetivas .

to curtindo de mais essa iniciativa de vcs ... meus parabens...

agora estou no aguardo da quarta aula...hehehe

[Matheus Brito 12]

Michel e Kisuke, para mim vcs estaum de parabens.......as aulas estaum bem claras e objetivas .

to curtindo de mais essa iniciativa de vcs ... meus parabens...

agora estou no aguardo da quarta aula...hehehe

 

 

Muito obrigado Anderson, estamos sempre tentando melhorar. E a quarta e quinta aula já estão saindo.

Abs