if(pObj[pAtributo] != null){
// Tem valor nesse atributo
}
[]s
Fábio
-----Mensagem original-----
De: flexdev@googlegroups.com [mailto:flexdev@googlegroups.com] Em nome de FabioBarreiro
Enviada em: sexta-feira, 8 de agosto de 2008 09:12
Para: flexdev
Assunto: [flexdev] propriedades de um Object
É possível vc descobrir se uma variável do tipo Object tem um certo atributo e pega-lo dinamicamente?
algo tipo:
private function Atributo(pObj:Object, pAtributo:String):Object {
?????
> if(pObj[pAtributo] != null){
> // Tem valor nesse atributo
> }
> []s
> Fábio
> -----Mensagem original-----
> De: flexdev@googlegroups.com [mailto:flexdev@googlegroups.com] Em nome de FabioBarreiro
> Enviada em: sexta-feira, 8 de agosto de 2008 09:12
> Para: flexdev
> Assunto: [flexdev] propriedades de um Object
> É possível vc descobrir se uma variável do tipo Object tem um certo atributo e pega-lo dinamicamente?
> algo tipo:
> private function Atributo(pObj:Object, pAtributo:String):Object {
> ?????
> On Aug 8, 9:17 am, "Fabio Goll" <fabio.g...@datasul.com.br> wrote:
> > if(pObj[pAtributo] != null){
> > // Tem valor nesse atributo
> > }
> > []s
> > Fábio
> > -----Mensagem original-----
> > De: flexdev@googlegroups.com [mailto:flexdev@googlegroups.com] Em nome de FabioBarreiro
> > Enviada em: sexta-feira, 8 de agosto de 2008 09:12
> > Para: flexdev
> > Assunto: [flexdev] propriedades de um Object
> > É possível vc descobrir se uma variável do tipo Object tem um certo atributo e pega-lo dinamicamente?
> > algo tipo:
> > private function Atributo(pObj:Object, pAtributo:String):Object {
> > ?????
> Date: Fri, 8 Aug 2008 05:54:53 -0700
> Subject: [flexdev] Re: RES: [flexdev] propriedades de um Object
> From: beck.nov...@gmail.com
> To: flexdev@googlegroups.com
> > if(pObj[pAtributo] != null){
> > // Tem valor nesse atributo
> > }
> Bem... se eu entendi bem a pergunta, ele quer verificar se o atributo
> existe, não se ele tem valor atribuído. Neste caso o correto seria:
> if ( pObj.hasOwnProperty(pAtributo) )
> {
> var valorAtributo = pObj[pAtributo];
> }
> ou, menos conhecido:
> if ( "pAtributo" in pObj )
> {
> var valorAtributo = pObj[pAtributo];
> }
> []'s
> Beck Novaes
> On Aug 8, 9:17 am, "Fabio Goll" <fabio.g...@datasul.com.br> wrote:
> > if(pObj[pAtributo] != null){
> > // Tem valor nesse atributo
> > }
> > []s
> > Fábio
> > -----Mensagem original-----
> > De: flexdev@googlegroups.com [mailto:flexdev@googlegroups.com] Em nome de FabioBarreiro
> > Enviada em: sexta-feira, 8 de agosto de 2008 09:12
> > Para: flexdev
> > Assunto: [flexdev] propriedades de um Object
> > É possível vc descobrir se uma variável do tipo Object tem um certo atributo e pega-lo dinamicamente?
> > algo tipo:
> > private function Atributo(pObj:Object, pAtributo:String):Object {
> > ?????
Já tô até vendo os purista torcendo o nariz, mas o caso é que isso é bem útil às vezes.
Essa é uma "manha" (alguém ainda fala assim?) do pessoal do flash, que usa AS há mais tempo. Postei aqui proque pensei que talvez muitos de vocês não saibam disso.
Estou falando de usar os colchetes para acessar propriedades de um objeto em runtime.
Por exemplo: Suponha que existam as seguintes constantes que representam ícones em minha aplicação IconDefinitions.as [Embed(source="assets/icons/book.png")] public static const Book:Class;
[Embed(source="assets/icons/notebook.png")] public static const NoteBook:Class;
Agora suponha que, em outra classe eu vou definir uma imagem no runtime (no exemplo eu seto um source de um SWFLoader). swfloader.source=Definitions["Book"];
_________________________________________________________________ News, entertainment and everything you care about at Live.com. Get it now! http://www.live.com/getstarted.aspx
Isso não é tão útil, lias pra mim parece mais uma gambiarra, pois o jeito
mais correto é a utilização da orientação a objetos, e é esse o propósito do
AS3.
Se sua classe for Definitions então use Definitions.Book.
Foi boa a intenção, mas não use mas dessa forma ai, procure SEMPRE usar
orientação a objetos, senão não vai fazer sentido usar AS3.
Novamente eu falo, obrigado pela colaboração, mas devemos sempre ter em
mente a orientação a objetos, pois tudo está baseado nela.
Abs.
2008/8/9 gabriela perry <gabrielape...@hotmail.com>
> Já tô até vendo os purista torcendo o nariz, mas o caso é que isso é bem
> útil às vezes.
> Essa é uma "manha" (alguém ainda fala assim?) do pessoal do flash, que usa
> AS há mais tempo. Postei aqui proque pensei que talvez muitos de vocês não
> saibam disso.
> Estou falando de usar os colchetes para acessar propriedades de um objeto
> em runtime.
> Por exemplo:
> Suponha que existam as seguintes constantes que representam ícones em minha
> aplicação
> IconDefinitions.as
> [Embed(source="assets/icons/book.png")]
> public static const Book:Class;
> [Embed(source="assets/icons/notebook.png")]
> public static const NoteBook:Class;
> Agora suponha que, em outra classe eu vou definir uma imagem no runtime (no
> exemplo eu seto um source de um SWFLoader).
> swfloader.source=Definitions["Book"];
> ------------------------------
> Get news, entertainment and everything you care about at Live.com. Check
> it out! <http://www.live.com/getstarted.aspx>
-- Atenciosamente,
Paulo Roberto.
Site: www.prsolucoes.com Msn: pa...@prsolucoes.com
Definitions.Book ou Definitions["Book"] são iguais Paulo... para o compilador não tem diferença nenhuma. Isso pq objetos em AS3 podem ser dinâmicos, ter propriedades anexadas em runtime. Assim como declarar dessa forma:
var obj : Object = {}; var obj : Object = new Object();
Ambos estão certos e compilados da mesma forma.
Depois veja sobre dynamic class in AS3.
A princípio eu não tinha entendido o email da Gabriela, até conversar com ela e ela me explicar q o compilador não testou o TIPO do objeto quando se usa colchetes, ou seja, o source ali não estava esperando um tipo Class, mas passou na compilação. Se caso ocorra algum problema de cast, esse problema vai "estourar" em runtime.
Não são iguais cara, você está fazendo algo desnecessário, como o Igor
disse, isso é uma gambiarra, se você quer acessar uma classe acesse do jeito
correto, para depois não ter problemas e ficar pesquisando o que pode ter
ocorrido.
Se fosse assim, não existiria O.O., existiria somente um monte de arrays
ninhados um dentro do outro.
> Definitions.Book ou Definitions["Book"] são iguais Paulo... para o
> compilador não tem diferença nenhuma.
> Isso pq objetos em AS3 podem ser dinâmicos, ter propriedades anexadas em
> runtime.
> Assim como declarar dessa forma:
> var obj : Object = {};
> var obj : Object = new Object();
> Ambos estão certos e compilados da mesma forma.
> Depois veja sobre dynamic class in AS3.
> A princípio eu não tinha entendido o email da Gabriela, até conversar com
> ela e ela me explicar q o compilador não testou o TIPO do objeto quando se
> usa colchetes, ou seja, o source ali não estava esperando um tipo Class, mas
> passou na compilação.
> Se caso ocorra algum problema de cast, esse problema vai "estourar" em
> runtime.
sim sim sim, é uma gambiarra (eu tinha avisado...), e dá pra resolver nesse caso com Dictionary e em outros com o pacote flash.utils, dá pra pensar em outros jeitos mais elegantes de fazer...
mas a intenção era expor mais uma forma de resolver problemas, e que é perfeitamente "legal" no AS.
Date: Sat, 9 Aug 2008 18:23:30 -0300
From: pa...@prsolucoes.com
To: flexdev@googlegroups.com
Subject: [flexdev] Re: "Enganando" o compilador
Olá Mário ,
Não são iguais cara, você está fazendo algo desnecessário, como o Igor disse, isso é uma gambiarra, se você quer acessar uma classe acesse do jeito correto, para depois não ter problemas e ficar pesquisando o que pode ter ocorrido.
Se fosse assim, não existiria O.O., existiria somente um monte de arrays ninhados um dentro do outro.
Definitions.Book ou Definitions["Book"] são iguais Paulo... para o compilador não tem diferença nenhuma.
Isso pq objetos em AS3 podem ser dinâmicos, ter propriedades anexadas em runtime. Assim como declarar dessa forma:
var obj : Object = {};
var obj : Object = new Object();
Ambos estão certos e compilados da mesma forma.
Depois veja sobre dynamic class in AS3.
A princípio eu não tinha entendido o email da Gabriela, até conversar com ela e ela me explicar q o compilador não testou o TIPO do objeto quando se usa colchetes, ou seja, o source ali não estava esperando um tipo Class, mas passou na compilação.
Se caso ocorra algum problema de cast, esse problema vai "estourar" em runtime.
-- Atenciosamente,
Paulo Roberto.
Site: www.prsolucoes.com Msn: pa...@prsolucoes.com
_________________________________________________________________
News, entertainment and everything you care about at Live.com. Get it now!
http://www.live.com/getstarted.aspx
Date: Sat, 9 Aug 2008 14:28:00 -0300
From: pa...@prsolucoes.com
To: flexdev@googlegroups.com
Subject: [flexdev] Re: "Enganando" o compilador
Isso não é tão útil, lias pra mim parece mais uma gambiarra, pois o jeito mais correto é a utilização da orientação a objetos, e é esse o propósito do AS3.
Se sua classe for Definitions então use Definitions.Book.
Foi boa a intenção, mas não use mas dessa forma ai, procure SEMPRE usar orientação a objetos, senão não vai fazer sentido usar AS3.
Novamente eu falo, obrigado pela colaboração, mas devemos sempre ter em mente a orientação a objetos, pois tudo está baseado nela.
Abs.
2008/8/9 gabriela perry <gabrielape...@hotmail.com>
Já tô até vendo os purista torcendo o nariz, mas o caso é que isso é bem útil às vezes.
Essa é uma "manha" (alguém ainda fala assim?) do pessoal do flash, que usa AS há mais tempo. Postei aqui proque pensei que talvez muitos de vocês não saibam disso.
Estou falando de usar os colchetes para acessar propriedades de um objeto em runtime.
Por exemplo:
Suponha que existam as seguintes constantes que representam ícones em minha aplicação
IconDefinitions.as
[Embed(source="assets/icons/book.png")]
public static const Book:Class;
[Embed(source="assets/icons/notebook.png")]
public static const NoteBook:Class;
Agora suponha que, em outra classe eu vou definir uma imagem no runtime (no exemplo eu seto um source de um SWFLoader).
Get news, entertainment and everything you care about at Live.com. Check it out!
-- Atenciosamente,
Paulo Roberto.
Site: www.prsolucoes.com Msn: pa...@prsolucoes.com
_________________________________________________________________
News, entertainment and everything you care about at Live.com. Get it now!
http://www.live.com/getstarted.aspx
> Não são iguais cara, você está fazendo algo desnecessário, como o Igor > disse, isso é uma gambiarra, se você quer acessar uma classe acesse do jeito > correto, para depois não ter problemas e ficar pesquisando o que pode ter > ocorrido.
> Se fosse assim, não existiria O.O., existiria somente um monte de arrays > ninhados um dentro do outro.
é oq ia dizer... mas achei melhor nao pq nao vai levar a lugar nenhum... Mas só pra título de curiosidade, quem conhece estrutura de dados, sabe q todo objeto nada mais é do que um array associativo, "binariamente" falando... são iguais... e não tem nada a haver com orientação a objetos (OO) .. isso é outra coisa... mas deixamos isso pra uma lista de estrutura de dados, e nas de Flex =D
Bem, eu queria começar dizendo que não considero isto uma gambiarra.
Simplesmente foi utilizada uma notação diferente para acessar o
Objeto. Isto é uma funcionalidade do ActionScript e, em minha opinião,
não podemos chamar de gambiarra aquilo que é funcionalidade. Agora, se
é a melhor solução é outra coisa.
Além disso, isto não tem nada a ver com Orientação a Objetos. Algumas
linguagens de programação não verificam o tipo em tempo de compilação
e nem por isso deixam de ser Orientadas a Objetos. OOP são três coisas
(por ordem de importância): Encapsulamento, Polimorfismo e Herança. O
fato de você usar a notação de colchetes ou a notação de ponto no Flex
tem a ver com a verificação em tempo de compilação ou execução. Quando
você usa a notação de ponto, se tiver algum erro você vai pegar antes
de executar o programa; se você usar a notação de colchetes o erro
aparecerá apenas em tempo de execução. E como em programação é melhor
você pegar o problema o quanto antes é melhor usar a notação de ponto
(novamente, não é isso que define se é OOP ou não).
[]'s
Beck Novaes
On 9 ago, 18:23, "Paulo Coutinho" <pa...@prsolucoes.com> wrote:
> Não são iguais cara, você está fazendo algo desnecessário, como o Igor
> disse, isso é uma gambiarra, se você quer acessar uma classe acesse do jeito
> correto, para depois não ter problemas e ficar pesquisando o que pode ter
> ocorrido.
> Se fosse assim, não existiria O.O., existiria somente um monte de arrays
> ninhados um dentro do outro.
> > Definitions.Book ou Definitions["Book"] são iguais Paulo... para o
> > compilador não tem diferença nenhuma.
> > Isso pq objetos em AS3 podem ser dinâmicos, ter propriedades anexadas em
> > runtime.
> > Assim como declarar dessa forma:
> > var obj : Object = {};
> > var obj : Object = new Object();
> > Ambos estão certos e compilados da mesma forma.
> > Depois veja sobre dynamic class in AS3.
> > A princípio eu não tinha entendido o email da Gabriela, até conversar com
> > ela e ela me explicar q o compilador não testou o TIPO do objeto quando se
> > usa colchetes, ou seja, o source ali não estava esperando um tipo Class, mas
> > passou na compilação.
> > Se caso ocorra algum problema de cast, esse problema vai "estourar" em
> > runtime.
Ah... só para completar. Você pode "desativar" a verificação em tempo
de compilação também (desta forma usar ponto ou colchetes, aí sim,
será a mesma coisa).
Menu Project -> Properties -> Flex Compiler -> Enable strict type
checking
A vantagem disso? O compilador fica bem mais rápido! Pode ser muito
útil em projetos grandes quando você quer fazer alguns testes rápidos
para ajudar determinada funcionalidade.
[]'s
Beck Novaes
On 11 ago, 09:01, Beck Novaes <beck.nov...@gmail.com> wrote:
> Bem, eu queria começar dizendo que não considero isto uma gambiarra.
> Simplesmente foi utilizada uma notação diferente para acessar o
> Objeto. Isto é uma funcionalidade do ActionScript e, em minha opinião,
> não podemos chamar de gambiarra aquilo que é funcionalidade. Agora, se
> é a melhor solução é outra coisa.
> Além disso, isto não tem nada a ver com Orientação a Objetos. Algumas
> linguagens de programação não verificam o tipo em tempo de compilação
> e nem por isso deixam de ser Orientadas a Objetos. OOP são três coisas
> (por ordem de importância): Encapsulamento, Polimorfismo e Herança. O
> fato de você usar a notação de colchetes ou a notação de ponto no Flex
> tem a ver com a verificação em tempo de compilação ou execução. Quando
> você usa a notação de ponto, se tiver algum erro você vai pegar antes
> de executar o programa; se você usar a notação de colchetes o erro
> aparecerá apenas em tempo de execução. E como em programação é melhor
> você pegar o problema o quanto antes é melhor usar a notação de ponto
> (novamente, não é isso que define se é OOP ou não).
> []'s
> Beck Novaes
> On 9 ago, 18:23, "Paulo Coutinho" <pa...@prsolucoes.com> wrote:
> > Olá Mário ,
> > Não são iguais cara, você está fazendo algo desnecessário, como o Igor
> > disse, isso é uma gambiarra, se você quer acessar uma classe acesse do jeito
> > correto, para depois não ter problemas e ficar pesquisando o que pode ter
> > ocorrido.
> > Se fosse assim, não existiria O.O., existiria somente um monte de arrays
> > ninhados um dentro do outro.
> > > Definitions.Book ou Definitions["Book"] são iguais Paulo... para o
> > > compilador não tem diferença nenhuma.
> > > Isso pq objetos em AS3 podem ser dinâmicos, ter propriedades anexadas em
> > > runtime.
> > > Assim como declarar dessa forma:
> > > var obj : Object = {};
> > > var obj : Object = new Object();
> > > Ambos estão certos e compilados da mesma forma.
> > > Depois veja sobre dynamic class in AS3.
> > > A princípio eu não tinha entendido o email da Gabriela, até conversar com
> > > ela e ela me explicar q o compilador não testou o TIPO do objeto quando se
> > > usa colchetes, ou seja, o source ali não estava esperando um tipo Class, mas
> > > passou na compilação.
> > > Se caso ocorra algum problema de cast, esse problema vai "estourar" em
> > > runtime.
Pois sabe que eu meio que tentei encerrar a discussão exatamente porque entrou nessa do que é OO e o que seriam boas práticas. Como voc6es devem saber, esse é um assunto que, se levássemos aos seus extremos, deixaríamos de fazer singletons e heranças... Conheço gente que acha singleton uma gambiarra...
Por isso que respondi Reply["OK"] : não vamos chegar num acordo (eu e o Paulo Coutinho) sobre isso. E como não sou teórica da computação, não entrarei nesta discussão.
Agora, é verdade que isso impede o compilador de dar avisos... Mas mesmo em relação à tipagem, existem melhores (upcast) e piores (downcast) formas de fazer isso.
Isso (e também o uso do operador []) está bem explicado no livro do Moock, AS2, que é uma referência melhor que eu :0)
> Date: Mon, 11 Aug 2008 05:01:37 -0700
> Subject: [flexdev] Re: "Enganando" o compilador
> From: beck.nov...@gmail.com
> To: flexdev@googlegroups.com
> Hm... interessante a discussão.
> Bem, eu queria começar dizendo que não considero isto uma gambiarra.
> Simplesmente foi utilizada uma notação diferente para acessar o
> Objeto. Isto é uma funcionalidade do ActionScript e, em minha opinião,
> não podemos chamar de gambiarra aquilo que é funcionalidade. Agora, se
> é a melhor solução é outra coisa.
> Além disso, isto não tem nada a ver com Orientação a Objetos. Algumas
> linguagens de programação não verificam o tipo em tempo de compilação
> e nem por isso deixam de ser Orientadas a Objetos. OOP são três coisas
> (por ordem de importância): Encapsulamento, Polimorfismo e Herança. O
> fato de você usar a notação de colchetes ou a notação de ponto no Flex
> tem a ver com a verificação em tempo de compilação ou execução. Quando
> você usa a notação de ponto, se tiver algum erro você vai pegar antes
> de executar o programa; se você usar a notação de colchetes o erro
> aparecerá apenas em tempo de execução. E como em programação é melhor
> você pegar o problema o quanto antes é melhor usar a notação de ponto
> (novamente, não é isso que define se é OOP ou não).
> > Não são iguais cara, você está fazendo algo desnecessário, como o Igor
> > disse, isso é uma gambiarra, se você quer acessar uma classe acesse do jeito
> > correto, para depois não ter problemas e ficar pesquisando o que pode ter
> > ocorrido.
> > Se fosse assim, não existiria O.O., existiria somente um monte de arrays
> > ninhados um dentro do outro.
> > > Definitions.Book ou Definitions["Book"] são iguais Paulo... para o
> > > compilador não tem diferença nenhuma.
> > > Isso pq objetos em AS3 podem ser dinâmicos, ter propriedades anexadas em
> > > runtime.
> > > Assim como declarar dessa forma:
> > > var obj : Object = {};
> > > var obj : Object = new Object();
> > > Ambos estão certos e compilados da mesma forma.
> > > Depois veja sobre dynamic class in AS3.
> > > A princípio eu não tinha entendido o email da Gabriela, até conversar com
> > > ela e ela me explicar q o compilador não testou o TIPO do objeto quando se
> > > usa colchetes, ou seja, o source ali não estava esperando um tipo Class, mas
> > > passou na compilação.
> > > Se caso ocorra algum problema de cast, esse problema vai "estourar" em
> > > runtime.
> Bem, eu queria começar dizendo que não considero isto uma gambiarra. > Simplesmente foi utilizada uma notação diferente para acessar o > Objeto. Isto é uma funcionalidade do ActionScript e, em minha opinião, > não podemos chamar de gambiarra aquilo que é funcionalidade.
quase todos os exemplos ae, são "funcionalidades" das linguagens, código que compila
dizer que "não podemos chamar de gambiarra aquilo que é funcionalidade" soa ingenup pra mim =)
ex: PHP tem uma biblioteca externa chamada runkit que permite mudar o valor de CONSTANTES, isso mesmo, mudar o valor de CONSTANTES onde está o POG? na mente do sujeito que pensou "ei, pode ser legal ficar mudando o valor de constantes, não acham?" =p o POG não está no codigo/funcionalidade em si, o POG surge quando você usa uma funcionalidade de forma inadequada ou desnecessária (na boa, mudar o valor de constantes!!! quando que isso poderia ser uma boa idéia? eu realmente não sei responder)
tem muita coisa que é funcionalidade que não deveria ser usada (tirando casos muito, MUITO excepcionais) e isso inclui também OO e Design Patterns =)
tente desenvolver uma aplicativo que necessite de resposta em tempo real (ex: um game multiplayer) e performance EXTREMA usando ao máximo Design Patterns, OO, Hibernate, EJBs, Flash/Flex e veja os resultados =)
o segredo para fugir do POG? conhecimento e bom senso para usar a funcionalidade certa para resolver o problema certo
> dizer que "não podemos chamar de gambiarra aquilo que é
> funcionalidade" soa ingenuo pra mim =)
Uma das coisas que eu aprendi nos meus mais de 10 anos de
desenvolvimento de Software (aproximadamente metade deles trabalhando
com RIA) é que ingenuidade é achar que estes debates são úteis de
alguma forma. Tenho uma opinião que creio ser coerente sobre o
assunto, mas por acreditar que isto não levará a lugar algum e por
saber que eu teria que escrever mais do que eu estaria disposto em
pleno domingo, reservo-me o direito de guardá-la para mim.
[]'s
Beck Novaes
On Aug 30, 12:23 am, "Marcelo Bezerra" <bezerra...@gmail.com> wrote:
> > Bem, eu queria começar dizendo que não considero isto uma gambiarra.
> > Simplesmente foi utilizada uma notação diferente para acessar o
> > Objeto. Isto é uma funcionalidade do ActionScript e, em minha opinião,
> > não podemos chamar de gambiarra aquilo que é funcionalidade.
> quase todos os exemplos ae, são "funcionalidades" das linguagens,
> código que compila
> dizer que "não podemos chamar de gambiarra aquilo que é
> funcionalidade" soa ingenup pra mim =)
> ex: PHP tem uma biblioteca externa chamada runkit que permite mudar o
> valor de CONSTANTES, isso mesmo, mudar o valor de CONSTANTES
> onde está o POG? na mente do sujeito que pensou "ei, pode ser legal
> ficar mudando o valor de constantes, não acham?" =p
> o POG não está no codigo/funcionalidade em si, o POG surge quando você
> usa uma funcionalidade de forma inadequada ou desnecessária
> (na boa, mudar o valor de constantes!!! quando que isso poderia ser
> uma boa idéia? eu realmente não sei responder)
> tem muita coisa que é funcionalidade que não deveria ser usada
> (tirando casos muito, MUITO excepcionais) e isso inclui também OO e
> Design Patterns =)
> tente desenvolver uma aplicativo que necessite de resposta em tempo
> real (ex: um game multiplayer) e performance EXTREMA usando ao máximo
> Design Patterns, OO, Hibernate, EJBs, Flash/Flex e veja os resultados
> =)
> o segredo para fugir do POG? conhecimento e bom senso para usar a
> funcionalidade certa para resolver o problema certo
>> dizer que "não podemos chamar de gambiarra aquilo que é
>> funcionalidade" soa ingenuo pra mim =)
> Uma das coisas que eu aprendi nos meus mais de 10 anos de
> desenvolvimento de Software (aproximadamente metade deles
> trabalhando com RIA) é que ingenuidade é achar que estes debates
> são úteis de alguma forma.
ae Beck, talvez eu tenha sido mal-interpretado, até mesmo por que por
email não dá pra ver coisas como tonalidade de voz ou a cara da pessoa
eu disse aquilo não para dizer que você era ingenuo ou coisa do tipo
(você é notoriamente um dos que mais contribuem nesta lista.... seria
injusto e ingenuo da minha parte) e sim meio que como uma ironia,
porque eu realmente não acha que só porque uma funcionalidade existe,
que ela não pode ser considerada gambiarra ...
nem tão pouco duvidei da sua experiência ou conhecimento (como você
citou que tem 10 anos de experiencia com software sendo 5 deles apenas
com RIA, eu supus que voce tenha entendido que eu duvidei da sua
expertise em algum momento)... quem sou eu pra fazer isso
desculpe se ofendi alguém =)
sobre a utilidade destes debates, eu não tenho a menor dúvida de que a
utilidade deles tende quase sempre a zero... eu gosto de contribuir e
"tocar fogo" em alguns debates (especialmente debates sobre boas
práticas de desenvolvimento ou sobre gambiarras) simplesmente porque é
divertido, muito divertido, ver as respostas (ainda mais se estivermos
numa comunidade com um indice elevado de trolls ou xiitas) =D
sim, eu sei, tem outras coisas mais divertidas do que ficar atiçando
trolls em listas de emails hueahuehauehau
> On Aug 30, 12:23 am, "Marcelo Bezerra" <bezerra...@gmail.com> wrote:
>> > Bem, eu queria começar dizendo que não considero isto uma gambiarra.
>> > Simplesmente foi utilizada uma notação diferente para acessar o
>> > Objeto. Isto é uma funcionalidade do ActionScript e, em minha opinião,
>> > não podemos chamar de gambiarra aquilo que é funcionalidade.
>> quase todos os exemplos ae, são "funcionalidades" das linguagens,
>> código que compila
>> dizer que "não podemos chamar de gambiarra aquilo que é
>> funcionalidade" soa ingenup pra mim =)
>> ex: PHP tem uma biblioteca externa chamada runkit que permite mudar o
>> valor de CONSTANTES, isso mesmo, mudar o valor de CONSTANTES
>> onde está o POG? na mente do sujeito que pensou "ei, pode ser legal
>> ficar mudando o valor de constantes, não acham?" =p
>> o POG não está no codigo/funcionalidade em si, o POG surge quando você
>> usa uma funcionalidade de forma inadequada ou desnecessária
>> (na boa, mudar o valor de constantes!!! quando que isso poderia ser
>> uma boa idéia? eu realmente não sei responder)
>> tem muita coisa que é funcionalidade que não deveria ser usada
>> (tirando casos muito, MUITO excepcionais) e isso inclui também OO e
>> Design Patterns =)
>> tente desenvolver uma aplicativo que necessite de resposta em tempo
>> real (ex: um game multiplayer) e performance EXTREMA usando ao máximo
>> Design Patterns, OO, Hibernate, EJBs, Flash/Flex e veja os resultados
>> =)
>> o segredo para fugir do POG? conhecimento e bom senso para usar a
>> funcionalidade certa para resolver o problema certo
Sobre o colchetes, isso realmente é util na utilização de prototype. Até a
versão 3, o compilador se atrapalhava com prototypes, e varios outros
cenários que manter uma variável como tipo "Object" travava no compilador.
Claro, teoricamente você não deveria precisar de prototype, e nem devia ter
tipos "genericos" de objetos, mas essa é outra discussão. :)
Também não acho que isso seja POG, acho sim que é uma funcionalidade, que
considero das melhores.
> Ah... só para completar. Você pode "desativar" a verificação em tempo
> de compilação também (desta forma usar ponto ou colchetes, aí sim,
> será a mesma coisa).
> Menu Project -> Properties -> Flex Compiler -> Enable strict type
> checking
> A vantagem disso? O compilador fica bem mais rápido! Pode ser muito
> útil em projetos grandes quando você quer fazer alguns testes rápidos
> para ajudar determinada funcionalidade.
> []'s
> Beck Novaes
> On 11 ago, 09:01, Beck Novaes <beck.nov...@gmail.com> wrote:
> > Hm... interessante a discussão.
> > Bem, eu queria começar dizendo que não considero isto uma gambiarra.
> > Simplesmente foi utilizada uma notação diferente para acessar o
> > Objeto. Isto é uma funcionalidade do ActionScript e, em minha opinião,
> > não podemos chamar de gambiarra aquilo que é funcionalidade. Agora, se
> > é a melhor solução é outra coisa.
> > Além disso, isto não tem nada a ver com Orientação a Objetos. Algumas
> > linguagens de programação não verificam o tipo em tempo de compilação
> > e nem por isso deixam de ser Orientadas a Objetos. OOP são três coisas
> > (por ordem de importância): Encapsulamento, Polimorfismo e Herança. O
> > fato de você usar a notação de colchetes ou a notação de ponto no Flex
> > tem a ver com a verificação em tempo de compilação ou execução. Quando
> > você usa a notação de ponto, se tiver algum erro você vai pegar antes
> > de executar o programa; se você usar a notação de colchetes o erro
> > aparecerá apenas em tempo de execução. E como em programação é melhor
> > você pegar o problema o quanto antes é melhor usar a notação de ponto
> > (novamente, não é isso que define se é OOP ou não).
> > []'s
> > Beck Novaes
> > On 9 ago, 18:23, "Paulo Coutinho" <pa...@prsolucoes.com> wrote:
> > > Olá Mário ,
> > > Não são iguais cara, você está fazendo algo desnecessário, como o Igor
> > > disse, isso é uma gambiarra, se você quer acessar uma classe acesse do
> jeito
> > > correto, para depois não ter problemas e ficar pesquisando o que pode
> ter
> > > ocorrido.
> > > Se fosse assim, não existiria O.O., existiria somente um monte de
> arrays
> > > ninhados um dentro do outro.
> > > > Definitions.Book ou Definitions["Book"] são iguais Paulo... para o
> > > > compilador não tem diferença nenhuma.
> > > > Isso pq objetos em AS3 podem ser dinâmicos, ter propriedades anexadas
> em
> > > > runtime.
> > > > Assim como declarar dessa forma:
> > > > var obj : Object = {};
> > > > var obj : Object = new Object();
> > > > Ambos estão certos e compilados da mesma forma.
> > > > Depois veja sobre dynamic class in AS3.
> > > > A princípio eu não tinha entendido o email da Gabriela, até conversar
> com
> > > > ela e ela me explicar q o compilador não testou o TIPO do objeto
> quando se
> > > > usa colchetes, ou seja, o source ali não estava esperando um tipo
> Class, mas
> > > > passou na compilação.
> > > > Se caso ocorra algum problema de cast, esse problema vai "estourar"
> em
> > > > runtime.
e bom pra galera refletir um pouco sobre o assunto
VLW E PAZ A TODOS
Att: Rivaldo Xavier da Silva Junior.
_________________________________________________________________ Instale a Barra de Ferramentas com Desktop Search e ganhe EMOTICONS para o Messenger! É GRÁTIS! http://www.msn.com.br/emoticonpack
> e bom pra galera refletir um pouco sobre o assunto
> VLW E PAZ A TODOS
> Att:* Rivaldo Xavier da Silva Junior.*
> ------------------------------
> Veja mapas e encontre as melhores rotas para fugir do trânsito com o Live
> Search Maps! Experimente já!<http://www.livemaps.com.br/index.aspx?tr=true>
>> e bom pra galera refletir um pouco sobre o assunto
>> VLW E PAZ A TODOS
>> Att:* Rivaldo Xavier da Silva Junior.*
>> ------------------------------
>> Veja mapas e encontre as melhores rotas para fugir do trânsito com o Live
>> Search Maps! Experimente já!<http://www.livemaps.com.br/index.aspx?tr=true>
>>> e bom pra galera refletir um pouco sobre o assunto
>>> VLW E PAZ A TODOS
>>> Att:* Rivaldo Xavier da Silva Junior.*
>>> ------------------------------
>>> Veja mapas e encontre as melhores rotas para fugir do trânsito com o Live
>>> Search Maps! Experimente já!<http://www.livemaps.com.br/index.aspx?tr=true>