Use o código e tenha 10% de desconto!

Cangaceiro JavaScript Uma aventura no sertão da programação

Flávio Almeida

Introdução

Talvez nenhuma outra linguagem tenha conseguido invadir o coletivo imaginário dos desenvolvedores como JavaScript fez. Em sua história fabular em busca de identidade, foi a única que conseguiu se enraizar nos navegadores, e nos últimos anos passou a empoderar servidores de alta performance através da plataforma Node.js. Com tudo isso, tornou-se uma linguagem em que todo desenvolvedor precisa ter algum nível de conhecimento.

Com a complexidade cada vez maior dos problemas, soluções ninjas não são mais suficientes; é preciso soluções cangaceiras. É nesse contexto que este livro se encaixa, ajudando-o a transcender seu conhecimento, tornando-o um Cangaceiro JavaScript. 

A quem se destina o livro

Este livro destina-se àqueles que desejam aprimorar a manutenção e legibilidade de seus códigos aplicando os paradigmas da Orientação a Objetos e da Programação Funcional, inclusive padrões de projetos. Por fim, ele ajudará também aqueles que desejam trabalhar com frameworks Single Page Application (SPA) conceituados do mercado, mas que carecem de um conhecimento mais aprofundado da linguagem JavaScript. 

Procurei utilizar uma linguagem simples para tornar este livro acessível a um amplo espectro de desenvolvedores. No entanto, é necessário que o leitor tenha algum conhecimento, mesmo que básico, da linguagem JavaScript para que tenha um melhor aproveitamento.

Visão geral da nossa jornada

O projeto deste livro será um cadastro de negociações de bolsa de valores. Ele será construído através do paradigma funcional e orientado a objetos ao mesmo tempo, utilizando o melhor dos dois mundos. 

Em um primeiro momento, o escopo da nossa aplicação pode parecer bem reduzido, mas é o suficiente para lançarmos mão de uma série de recursos acumulados na linguagem até a sua versão ECMAScript 2017 (ES8).

Para que o leitor prepare suas expectativas sobre o que está por vir, segue um breve resumo de cada capítulo:

Capítulo 01: escreveremos um código rapidamente sem nos preocuparmos com boas práticas ou sua reutilização, sentindo na pele as consequências dessa abordagem. É a partir dele que toda a trama do livro dará início, inclusive a motivação para uma estrutura aplicando o modelo MVC.

Capítulo 02: materializar uma representação de algo do mundo real em código é uma das tarefas do desenvolvedor. Veremos como o paradigma orientado a objetos pode nos ajudar na construção de um modelo.

Capítulo 03: do que adianta um modelo se o usuário não pode interagir com ele? Criaremos um controller, a ponte entre as ações do usuário e o modelo.

Capítulo 04: lidar com data não é uma tarefa trivial em qualquer linguagem, mas se combinarmos recursos da própria linguagem JavaScript pode ser algo bem divertido.

Capítulo 05: não é apenas uma negociação que possui regras, uma lista de negociação também. Criaremos mais um modelo com suas respectivas regras.

Capítulo 06: do que adianta termos um modelo que é modificado pelo usuário se ele não consegue ver o resultado? Aprenderemos a ligar o modelo com a view.

Capítulo 07: criar um modelo, modificá-lo com as ações do usuário e apresentá-lo é uma tarefa corriqueira. Será que podemos isolar esse processo e reutilizá-lo? Com certeza!

Capítulo 08: jogar a responsabilidade de atualizar a view no colo do desenvolvedor toda vez que o modelo mudar está sujeito a erros. Aprenderemos a automatizar esse processo.

Capítulo 09: aplicaremos o padrão de projeto Proxy para implementarmos nossa própria solução de data binding, que consiste na atualização da view toda vez que o modelo sofrer alterações.

Capítulo 10: isolaremos a responsabilidade da criação de proxies em uma classe, aplicando o padrão de projeto Factory e permitindo que ela seja reutilizada pela nossa aplicação.

Capítulo 11: aprenderemos a lidar com exceções, inclusive a criá-las.

Capítulo 12: trabalharemos com o velho conhecido XMLHttpRequest para nos integrarmos com a API fornecida com o projeto.

Capítulo 13: combateremos o callback hell, resultado da programação assíncrona com callbacks através do padrão de projeto Promise. Isolaremos a complexidade de se trabalhar com o XMLHttpRequest em classes de serviços.

Capítulo 14: negociações cadastradas são perdidas toda vez que a página é recarregada ou quando o navegador é fechado. Utilizaremos o IndexedDB, um banco presente em todo navegador para persistir nossas negociações.

Capítulo 15: não basta termos uma conexão com o IndexedDB. Aplicaremos um conjunto de boas práticas para lidar com a conexão, facilitando assim a manutenção e legibilidade do código.

Capítulo 16: aplicaremos o padrão de projeto DAO para esconder do desenvolvedor os detalhes de acesso ao banco e tornar ainda mais legível o código escrito.

Capítulo 17: o tendão de Aquiles da linguagem JavaScript sempre foi o escopo global e as dependências entre scripts, jogando a responsabilidade da ordem de carregamento no colo do desenvolvedor. Aprenderemos a usar o sistema de módulos padrão do próprio JavaScript para atacar esses problemas. Durante esse processo, aprenderemos a lidar com Babel, o transcompilador mais famoso do mundo open source.

Capítulo 18: veremos como o uso de promises com async/wait torna nosso código assíncrono mais fácil de ler e de manter. Aplicaremos mais padrões de projetos.

Capítulo 19: aplicaremos o padrão de projeto Decorator com auxílio do Babel, inclusive aprenderemos a realizar requisições assíncronas através da API Fetch, simplificando ainda mais nosso código. Nos aprofundaremos na metaprogramação com reflectmetadata.

Capítulo 20: utilizaremos Webpack para agrupar nossos módulos e aplicar boas práticas em tempo de desenvolvimento e de produção. Inclusive aprenderemos a fazer o deploy da aplicação no GitHub Pages.

Ao final do livro, o leitor terá um arsenal de recursos da linguagem e padrões de projetos que vão ajudá-lo a resolver problemas do dia a dia. A criação de um miniframework é apenas para deixar a aprendizagem mais divertida.

Por fim, o leitor poderá acompanhar o autor pelo twitter @flaviohalmeida e pelo blog http://cangaceirojavascript.com.br.

Agora que já temos uma visão geral de cada capítulo, veremos o download do projeto e a infraestrutura mínima necessária.

Infraestrutura necessária

A infraestrutura necessária para o projeto construído até o capítulo 10 é apenas o Google Chrome. É importante que esse navegador seja usado, pois só atacaremos questões de compatibilidade a partir do capítulo 11. Ao final do livro, sinta-se à vontade para utilizar qualquer navegador.

Do capítulo 12 em diante, precisaremos do Node.js (https://nodejs.org/en/) instalado. Durante a criação deste projeto, foi utilizada a versão 8.1.3. Mas não há problema baixar versões mais novas, contanto que sejam versões pares, as chamadas versões LTS (long term support).

 

Sumário

  • Parte 1 - O caminho do cangaceiro
  • 1 Prólogo: era uma vez no sertão
    • 1.1 O problema do nosso código
    • 1.2 O padrão MVC (Model-View-Controller)
  • 2 Negociar com o cangaceiro, tem coragem?
    • 2.1 O papel de um modelo
    • 2.2 A classe Negociação
    • 2.3 Construtor de classe
    • 2.4 Métodos de classe
    • 2.5 Encapsulamento
    • 2.6 A sintaxe get
    • 2.7 Objetos imutáveis
    • 2.8 A instância é imutável mesmo?
    • 2.9 Programação defensiva
    • 2.10 Menos verbosidade no constructor com Object.assign
    • 2.11 Atalho para propriedades de objetos literais
    • 2.12 As surpresas de declarações com var
    • 2.13 Declaração de variáveis com let
    • 2.14 Temporal Dead Zone
  • 3 No cangaço, é ação para todo lado
    • 3.1 O papel de um controlador
    • 3.2 A classe NegociacaoController
    • 3.3 Associando métodos do controller às ações do usuário
    • 3.4 Evitando percorrer desnecessariamente o DOM
    • 3.5 Criando uma instância de Negociação
    • 3.6 Criando um objeto Date a partir da entrada do usuário
    • 3.7 Um desafio com datas
    • 3.8 Resolvendo um problema com o paradigma funcional
    • 3.9 Arrow functions: deixando o código ainda menos verboso
  • 4 Dois pesos, duas medidas?
    • 4.1 Isolando a responsabilidade de conversão de datas
    • 4.2 Métodos estáticos
    • 4.3 Template string
    • 4.4 A boa prática do fail-fast
  • 5 O bando deve seguir uma regra
    • 5.1 Criando um novo modelo
    • 5.2 O tendão de Aquiles do JavaScript
    • 5.3 Blindando o nosso modelo
  • 6 A moda no cangaço
    • 6.1 O papel da View
    • 6.2 Nossa solução de View
    • 6.3 Construindo um template dinâmico com a função map
    • 6.4 Totalizando o volume de negociações
    • 6.5 Totalizando com reduce
  • 7 O plano
    • 7.1 Parâmetro default
    • 7.2 Criando a classe MensagemView
    • 7.3 Herança e reutilização de código
    • 7.4 Classes abstratas?
    • 7.5 Para saber mais: super
    • 7.6 Adquirindo um novo hábito com const
  • Parte 2 - Força Volante
  • 8 Um cangaceiro sabe delegar tarefas
    • 8.1 E se atualizarmos a View quando o modelo for alterado?
    • 8.2 Driblando o this dinâmico
    • 8.3 Arrow function e seu escopo léxico
  • 9 Enganaram o cangaceiro, será?
    • 9.1 O padrão de projeto Proxy
    • 9.2 Aprendendo a trabalhar com Proxy
    • 9.3 Construindo armadilhas de leitura
    • 9.4 Construindo armadilhas de escrita
    • 9.5 Reflect API
    • 9.6 Um problema não esperado
    • 9.7 Uma solução para que nossas armadilhas funcionem
    • 9.8 Construindo armadilhas para métodos
    • 9.9 Uma pitada do ES2016 (ES7)
    • 9.10 Aplicando a solução em NegociacaoController
  • 10 Cúmplice na emboscada
    • 10.1 O padrão de projeto Factory
    • 10.2 Nosso proxy ainda não está 100%!
    • 10.3 Associando modelo e View através da classe Bind
    • 10.4 Parâmetros REST
  • 11 Data dos infernos!
    • 11.1 O problema com o input date
    • 11.2 Ajustando nosso converter
    • 11.3 Lidando com exceções
    • 11.4 Criando nossa própria exceção: primeira tentativa
    • 11.5 Criando nossa própria exceção: segunda tentativa
  • 12 Pilhando o que interessa!
    • 12.1 Servidor e infraestrutura
    • 12.2 Requisições Ajax com o objeto XMLHttpRequest
    • 12.3 Realizando o parse da resposta
    • 12.4 Separando responsabilidades
  • 13 Lutando até o fim
    • 13.1 Callback HELL
    • 13.2 O padrão de projeto Promise
    • 13.3 Criando Promises
    • 13.4 Criando um serviço para isolar a complexidade do XMLHttpRequest
    • 13.5 Resolvendo Promises sequencialmente
    • 13.6 Resolvendo Promises paralelamente
    • 13.7 Ordenando o período
    • 13.8 Impedindo importações duplicadas
    • 13.9 As funções filter() e some()
  • Parte 3 - A revelação
  • 14 A algibeira está furada!
    • 14.1 IndexedDB, o banco de dados do navegador
    • 14.2 A conexão com o banco
    • 14.3 Nossa primeira store
    • 14.4 Atualização do banco
    • 14.5 Transações e persistência
    • 14.6 Cursores
  • 15 Colocando a casa em ordem
    • 15.1 A classe ConnectionFactory
    • 15.2 Criando Stores
    • 15.3 Garantindo uma conexão apenas por aplicação
    • 15.4 O padrão de projeto Module Pattern
    • 15.5 Monkey Patch: grandes poderes trazem grandes responsabilidades
  • 16 Entrando na linha
    • 16.1 O padrão de projeto DAO
    • 16.2 Criando nosso DAO de negociações
    • 16.3 Implementando a lógica de inclusão
    • 16.4 Implementando a lógica da listagem
    • 16.5 Criando uma DAOFactory
    • 16.6 Combinando padrões de projeto
    • 16.7 Exibindo todas as negociações
    • 16.8 Removendo todas as negociações
  • 17 Dividir para conquistar
    • 17.1 Módulos do ES2015 (ES6)
    • 17.2 Instalando o loader
    • 17.3 Transformando scripts em módulos
    • 17.4 O papel de um transcompilador
    • 17.5 Babel, instalação e build-step
    • 17.6 Sourcemap
    • 17.7 Compilando arquivos em tempo real
    • 17.8 Barrel, simplificando a importação de módulos
  • 18 Indo além
    • 18.1 ES2017 (ES8) e o açúcar sintático async/await
    • 18.2 Para saber mais: generators
    • 18.3 Refatorando o projeto com async/wait
    • 18.4 Garantindo a compatibilidade com ES2015
    • 18.5 Lidando melhor com exceções
    • 18.6 Debounce pattern: controlando a ansiedade
    • 18.7 Implementando o Debounce pattern
  • 19 Chegando ao limite
    • 19.1 O padrão de projeto Decorator
    • 19.2 Suportando Decorator através do Babel
    • 19.3 Um problema não esperado com nosso Decorator
    • 19.4 Elaborando um DOM Injector
    • 19.5 Decorator de classe
    • 19.6 Simplificando requisições Ajax com a API Fetch
    • 19.7 Configurando uma requisição com API Fetch
    • 19.8 Atalho para a propriedade de objetos literais
    • 19.9 Validação com parâmetro default
    • 19.10 Reflect-metadata: avançando na metaprogramação
    • 19.11 Adicionando metadados com Decorator de método
    • 19.12 Extraindo metadados com um Decorator de classe
  • 20 Enfrentamento final
    • 20.1 Webpack, agrupador de módulos
    • 20.2 Preparando o terreno para o Webpack
    • 20.3 O temível webpack.config.js
    • 20.4 Babel-loader, a ponte entre o Webpack e o Babel
    • 20.5 Preparando o build de produção
    • 20.6 Mudando o ambiente com cross-env
    • 20.7 Webpack Dev Server e configuração
    • 20.8 Tratando arquivos CSS como módulos
    • 20.9 Resolvendo o FOUC (Flash of Unstyled Content)
    • 20.10 Resolvemos um problema e criamos outro, mas tem solução!
    • 20.11 Importando scripts
    • 20.12 Lidando com dependências globais
    • 20.13 Otimizando o build com Scope Hoisting
    • 20.14 Separando nosso código das bibliotecas
    • 20.15 Gerando a página principal automaticamente
    • 20.16 Simplificando ainda mais a importação de módulos
    • 20.17 Code splitting e Lazy loading
    • 20.18 System.import vs import
    • 20.19 Quais são os arquivos de distribuição?
    • 20.20 Deploy do projeto no Github Pages
    • 20.21 Alterando o endereço da API no build de produção
    • 20.22 Considerações finais

Dados do produto

Número de páginas:
502
ISBN:
978-85-94188-00-7
Data publicação:
08/2017

Compartilhe!

Compartilhe no Facebook Compartilhe no Twitter