Boas,
o teu mail é uma excelente fonte de informação (digna de um post no
blog ;) ), e possui um conjunto de armas poderosas. Mas quero só
alertar que as armas que apresentaste são facas de dois gumes, pois mal
utilizadas podem resultar em más práticas. Pessoalmente prefiro ter as
coisas fortemente tipificadas (strong typing), com os parâmetros todos
bem descritos, nomenclatura correcta, etc, para garantir a manutenção,
escalabilidade, e legibilidade do código - requisitos essenciais,
especialmente num projecto open-source.
Porém, obviamente há casos em que as ferramentas que descreveste são
indispensáveis e devem ser utilizadas.
Envio só este mail para te dar os parabéns pelas sugestões e alertar
para facto de que, na minha opinião, é preciso pensar seriamente se não
haverão outras alternativas antes de se prosseguir para soluções
baseadas em rest (número aleatório de parâmetros), * (weak typing), ou
Object (strong typing para uma generalização demasiado genérica, que
obrigará a Casting).
João Saleiro
CTO @ Webfuel
Adobe Certified Expert
Adobe Community Expert
Co-founder of the Portuguese RIA Community
Cain Vampyr wrote:
Olá Cátia, antes de mais bem vinda a bordo.
Se bem entendi a tua duvida não se limite a um problema especifico mas
sim a entender a natureza dos argumentos de uma função.
Existem algumas"características" que deves ter em mente quando planeias
as tuas funções ou métodos.
Em primeiro lugar lembra-te que o nome de um argumento passado numa
função e atribuído na declaração da mesma, isto significa que se
pretendes que a função aceite um numero incerto de argumentos não podes
depender destes nomes.
Como já deves saber a quando da declaração de uma função, dentro dos (),
podes declarar a ordem, e devidos nomes e tipos de valor, de cada
argumento que esta vai aceitar, ex:
public function myFunction (_sArg1:String, _sArg2:Number, _arg3:*):void{}
A primeira nuance que deves ter em conta e o tipo '*' que basicamente
significa que esse argumento aceita qqer tipo de valor. A desvantagem de
declarar algo como '*' e de que consome muito mais recursos visto que
tem de manter espaço em memoria que possa comportar qqer tipo de valor,
em oposição a um uint que despende de uma fracção ínfima de um '*'. No
entanto ao poder aceitar qquer tipo de valor da-te liberdade para
passares argumentos extra que não sabes a partida qual ser o seu tipo o
que possa partilhar tipos diferentes que não descendam de um tipo em comum.
Existe no entanto, desde o as3, uma opção que podes usar na declaração
de uma função não só para que possa aceitar argumentos de tipos não
declarados como também um numero incerto de argumentos o '...', rest, ex:
poublic function myFunction (_sArg1:String, _sArg2:int, ... aArgList):void{}
ou simplesmente:
public function myFunction (... aArgList):void{}
Esta opção permite-te aceder a um array indexado com cada um dos valores
passados como argumentos desta função, estes valores não são atribuídos
a qqer "variável", como tal não são limitados a declaração de um tipo,
existem exclusivamente nos indexes do array, ordenados pela ordem da
chamada a função, ex:
myFunction("var1", 2, true);
iria resultar num array com o seguinte aspecto:
aArgList = ["var1", 2, true];
ou
aArgList[0] = "var1";
aArgList[1] = 2;
aArgList[2] = true;
Por ultimo, esta e a forma que uso com mais frequência quando tenho
mesmo de criar uma função assim tão flexível, coisa que evito a todo o
custo... podes sempre utilizar um argumento único do tipo "Object" no
qual podes passar qquer tipo e numero de argumentos associados aos nomes
que quiseres, no entanto esta forma e mais pesada a todos os níveis de
recursos, memoria e processador, ex:
Declaração:
public function myFunction (oAttributes:Object):void {
var _sName:String;
for (_sName in oAttributes) {
var _value:* = oAttributes[_sName];
trace ("Argument: " + _sName + ", Value: " + _value);
}
}
Chamada:
public myFunction ({arg1:"value1", arg2:2, arg3:true});
Output:
Argument: arg1, Value: value1
Argument: arg2, Value: 2
Argument: arg3, Value: true
Repara que neste caso eu limitei-me a fazer um trace com o nome e valor
de cada argumento mas podia facilmente atribuilos como valores a propria
class, ex:
Declarações:
protected var arg1:String;
protected var arg2:int;
protected var arg3:Boolean;
public function myFunction (oAttributes:Object):void {
var _sName:String;
for (_sName in oAttributes) {
var _value:* = oAttributes[_sName];
this[_sName] = _value;
}
}
Outras coisas que podes ter em mente, tal como já foi sugerido antes, e
que não tenhas de depender da passagem de argumentos no creator
function, o que e o mais aconselhado, alias de facto deves de evitar
depender do creator function o máximo possível. Sugestões quanto a
"propriedades" da classe, usa setters e getters, não só permitem definir
propriedades como sendo de leitura e/ou de escrita assim como despontar
outras acções sempre que estas mudam de valor, que por sua vez abre
portas para programação assincronica, ex:
Declaração:
protected var _arg1:String;
public function set arg1(v:String):void { this._arg1 = v; }
public function get arg1():String { return "GET: " + this._arg1; }
Chamada:
this.arg1 = "teste";
trace (this.arg1); // GET: teste
Para adicionar uma acção basta inclui-la no setter, ex:
Declarações:
internal _update:Boolean;
pulbic function Render():void {
trace("Redraw the view");
this._update = true;
}
public function set arg1(v:String):void { this._arg1 = v; this.Render() }
Repara que sempre que mudares o valor do arg1 de agora em diante a
função Render e despontada. Se por alguma razão tivesses uma rotina a
correr "onEnterFrame" ou outro método idêntico que escuta-se o valor
daquela propriedade '_update', independentemente do numero de chamadas
da função Render apenas seria efectivamente executado 1 vez quando
fosses testado o valor dessa propriedade na próxima instanciação dessa
rotina... espero ter ajudado assumindo que percebi a tua duvida original :X
Cátia Rodrigues wrote:
Boa tarde,
Antes de mais, sendo este o meu primeiro post nesta comunidade, vou
começar por me apresentar.
O meu nome é Cátia Rodrigues e estou a acabar o curso profissional de
multimédia na ETIC.
Para prova final de curso escolhi elaborar uma mini framework em AS3
que tem como características: Navegação com SWFADDRESS e multi-
language.
Esta framework terá a sua primeira versão acabada até ao final de
Junho e será colocada online como OpenSource.
Neste momento preciso de criar uma classe para o menu e preciso de
passar vários parâmetros como a font, o tipo de menu, cores, etc.
ex:
--> menu_mc = new MenuClass("vertical",
20,_fffCamera,"0xFFFFFF","0xFF0000");
---> public function MenuClass
(_type:String,_distance:Number,_font:Font,_fontColor:String,_fontHover:String):void
A minha duvida neste caso é como tratar os parâmetros recebidos na
classe, pois nem todos são obrigatórios e não correspondem a uma ordem
específica..
Desde já agradeço a ajuda :)
Cátia Rodrigues.
--~--~---------~--~----~------------~-------~--~----~
Recebeu esta mensagem porque está inscrito em Grupo "Mailing List da Comunidade Portuguesa de Rich Internet Applications - www.riapt.org" do Grupos Google.
Para enviar mensagens para este grupo, envie um email para [email protected]
Para anular a inscrição neste grupo, envie um email para [email protected]
Para mais opções, visite este grupo em http://groups.google.com/group/riapt?hl=pt-PT
-~----------~----~----~----~------~----~------~--~---
|
