Aprendendo JavaScript – da perspectiva de um desenvolvedor .Net

Eu venho futucando com JavaScript pelo menos desde 1998 ou 1999. Talvez um pouquinho antes.
Mas a grande verdade é que eu nunca peguei pra aprender a linguagem – e uma plataforma correspondente – com o mesmo empenho e na mesma profundidade que dediquei a outras como, por exemplo, Clipper ’87 e 5; Microsoft Access (Access Basic e depois VBA); Visual Basic e por fim C# e VB.NET.

Sempre que precisei fazer alguma coisa que fosse executado num browser, eu partia de uma base fundamental de conhecimento (boa parte da qual aplicável a outras linguagens) e aprendia o resto sob demanda, muitas vezes na base da tentativa e erro, mexendo aqui e ali até conseguir fazer a coisa funcionar – ou desistir.
Muitas vezes, uma parte do conhecimento adquirido na execução da tarefa acabava se perdendo já que no dia-a-dia, o meu foco estava focado em aplicações front-end nativas (que rodam fora do browser) e sistemas back-end usando outra technology stack.

Bom… Há pouco mais de uma semana eu fiz umas fotos lá no Bom Retiro e vi no material uma boa oportunidade de brincar com uma idéia que que venho querendo implementar já há algum tempo.

A idéia era distribuir num mapa marcadores apontando para os locais onde cada foto foi feita. Clicando ou tocando no marcador, abre-se um painel flutuante com a foto correspondente.

Se a resolução do dispositivo que você está usando for baixa, talvez você prefira ver o mapa rodando em tela cheia fora do blog. Neste caso, siga este link, mas não se esqueça de voltar pra cá!

Durante a prototipação eu encontrei as dificuldades costumeiras para quem detém somente um conhecimento básico de uma das ferramentas que está usando – nesse caso JavaScript – e nenhum conhecimento do restante do ferramental: JSON, JSONP, jQuery (que acabei não usando) e as APIs do Flickr e do Google Maps.

Mas o que me deixou particularmente frustrado foi uma hora em que eu estava tentando fazer o painel flutuante funcionar. Na pressa e não tendo lido a documentação com a atenção necessária – especialmente o trecho

The content of the InfoWindow may contain a string of text, a snippet of HTML, or a DOM element. To set the content, either specify it within the InfoWindowOptions or call setContent() on the InfoWindow explicitly.

, eu passei o olho no trecho abaixo
e traduzí isso usando o meu conhecimento de C# e VB.NET como sendo um construtor com um parâmetro nomeado – parâmetro este que seria atribuído à propriedade content do InfoWindow Como eu estava reaproveitando o InfoWindow pra exibir as diferentes fotos, era necessário alterar seu conteúdo cada vez em que o marcador fosse clicado e para isto, eu atribuía o conteúdo a infoWindow.content em outra parte do código. O problema é que infoWindow.content que na terminologia do JavaScript é uma propriedade está implementado no que seria equivalente no .Net a um campo (public instance field) e não uma propriedade (property).  Num campo, o código externo referencia o campo diretamente, enquanto que numa propriedade o acesso se dá pelo que chamamos property accessors que nada mais são que rotinas que são executadas para obter ou atribuir um valor à propriedade. O detalhe é que a rotina pode fazer outras coisas além disto, como por exemplo, atualizar a UI com o valor recebido. Pois bem, InfoWindow.content não tem o código necessário para atualizar a UI. Depois de bater um pouco a cabeça eu acabei descobrindo que deveria usar InfoWindow.setContent() e então o problema foi resolvido. Depois deste episódio e levando em conta que muitas das coisas que estou querendo fazer envolvem JavaScript, resolvi tomar vergonha e estudar o assunto na profundidade que ele merece. Para tanto, comprei o JavaScript: The Definitive Guide.

O livro é um calhamaço com mais de 1000 páginas sendo que destas, umas 700 podem ser lidas sequencialmente. As outras 300 tem o formato referência “guia” de referência para a linguagem e os recursos client-side do JavaScript. Tendo lido um pouco mais que 250 páginas, posso dizer que estou gostando bastante. Os primeiros capítulos foram os mais interessantes, já que foram apresentadas uma série de particularidades e nuances da linguagem – que eu não conhecia – de uma forma que foi possível mapeá-las com facilidade ao meu conhecimento existente na plataforma .Net e suas linguagens. Em vários momentos, eu lembrei dos livros de especificação do C#, VB.NET e do CLR via C# – excelentes títulos para quem quer dominar os conceitos fundamentais de .Net que servem de base para tudo que vem acima: ASP.NET, WPF, WCF, etc… Uma das primeiras coisas que me surpreendeu – e que tomei nota:

Mas tem muito mais: Particularidades sobre escopo de variáveis em funções aninhadas (closures) ou durante a execução de eval(), “herança” via prototypes, sutilezas do strict mode, funcionamento dos objetos nativos do JavaScript, delete, loop for in e por aí vai…

O nível de detalhe com o que o autor trata cada assunto me agradou bastante. Pelo menos enquanto ele trata de tópicos sobre os quais eu tinha nenhum ou pouco conhecimento, mas ficou meio chato em alguns trechos onde o mapeamento do conhecimento de JavaScript para C# é mais direto ou quando ele cria polyfills e outras alternativas para implementar em ECMAScript 3 recursos nativos do ECMAScript 5.

Neste último caso, eu achei que o código apresentado nem sempre tem o mesmo nível de qualidade e atenção a detalhe que o texto que o acompanha. Lendo o texto, em mais de uma ocasião foi possível elaborar o código mais simples e/ou mais robusto que o apresentado no livro.

O primeiro exemplo que me vem à cabeça, são os exemplos de código onde ele define o prototype de um construtor. Vários dos exemplos iniciais criam objetos para prototype do zero descartando no processo, o prototype original – ao invés de construir em cima dele. Embora as duas formas tenham os seus usos e aplicações, me parece que é mais usual ir adicionando os novos membros (propriedades e funções) em cima do prototype existente.

Outro trecho cansativo é o capítulo onde ele tenta emular no JavaScript, caraterísticas de orientação a objetos nativas a linguagens como Java (e C# apesar dele não ter citado este último) como encapsulamento, abstração, etc.

Muita gente deve querer e pedir por este tipo de exemplos, mas a impressão que dá, é que se está tentando forçar a linguagem a ser uma coisa que ela não é. As soluções apresentadas podem apetecer a quem reza unicamente pela cartilha da orientação a objetos, mas me deixaram imaginando se não seria o caso desse pessoal abrir a mente e abraçar outras abordagens, como a programação funcional ou mesmo procedural – não no lugar da, mas em adição à orientação a objetos.

Com ou apesar destas ressalvas, da parte que li até agora, numa escala de 1 a 5 eu daria nota 4 para o livro.

Agora deixa eu voltar pro livro porque eu estou doido pra descobrir quem matou o objeto que apareceu lá no Garbage Collector 😉