Tudo é objeto

1.1 Objetos e classes

Hoje você vai aprender como funciona um típico programa em JavaScript. E a grande novidade: cada programa em JavaScript é composto por classes e objetos. JavaScript é uma linguagem orientada a objetos, e tudo nela é objeto: números, strings, funções e até classes.

Então, o que são classes?

Vou começar com uma analogia. Imagine que você quer fazer um pequeno navio. Primeiro, você precisa fazer um projeto, depois entregá-lo à fábrica, onde navios serão montados de acordo com este projeto. Ou uma dezena. Na verdade, quantos navios quiser. De um projeto são construídos dezenas de navios idênticos, isso é o que importa.

No desenvolvimento com JavaScript é exatamente a mesma coisa.

Projetos

O programador é o mesmo que um projetista. Só que o projetista desenha projetos, e o programador em JavaScript escreve classes. Depois, com base nos projetos, são criadas as peças, e com base nas classes, os objetos.

Primeiro escrevemos classes (fazemos projetos), e depois, durante a execução do programa, com base nessas classes, o JavaScript cria objetos. Exatamente como navios são criados com base em projetos.

Um projeto só, mas podem ser muitos navios. Navios diferentes, eles têm nomes diferentes, carregam cargas diferentes. Mas eles são muito parecidos: todos são navios com construção idêntica, e podem realizar tarefas semelhantes.

Ou aqui vai outra analogia...

Formigueiro

O formigueiro é um bom exemplo de interação de objetos. Em um formigueiro simples, existem três classes de formigas: rainha, soldados e operárias.

O número de formigas de cada classe é diferente. A rainha é uma para todo o formigueiro, há dezenas de soldados e centenas de formigas operárias. Três classes e centenas de objetos. As formigas interagem umas com as outras, com formigas iguais e formigas de outras classes segundo regras bem definidas.

Este é apenas um exemplo ideal. Em um programa típico, tudo é exatamente igual. Existe um objeto principal, que cria objetos de todas as outras classes. Os objetos começam a interagir entre si e com o "mundo exterior" do programa. Dentro destes objetos, o comportamento é rigidamente programado.

Essas duas explicações são dois lados da mesma moeda. A verdade está no meio. O primeiro exemplo (sobre projeto e navios) mostra a relação entre uma classe e os objetos dessa classe. A analogia é muito forte. O segundo exemplo (sobre formigueiro) mostra a relação entre os objetos que existem durante o funcionamento do programa e as classes escritas.

Primeiro, você deve escrever classes para todos os objetos existentes no programa, e depois ainda descrever suas interações. Parece complicado, mas é mais fácil do que parece.

Em JavaScript, todas as entidades durante a execução do programa são objetos, e escrever um programa se resume a descrever várias maneiras de interação dos objetos. Os objetos simplesmente chamam métodos uns dos outros e passam os dados necessários.

Documentação

E como saber quais dados passar para os métodos? Tudo isso já foi pensado antes de você.

Normalmente, cada classe tem uma descrição que diz para que ela foi criada. Também é comum que cada método público tenha uma descrição: o que ele faz e quais dados precisam ser passados para ele.

Para usar uma classe, é necessário ter uma ideia geral do que ela faz. E também é preciso saber exatamente o que cada método dela faz. E não é necessário saber como ele faz isso. Uma espécie de varinha mágica.

Vamos dar uma olhada no código — copiando um arquivo:

    
      const fs = require('fs');

      // Abrir arquivos
      const src = fs.createReadStream('source.txt');
      const dst = fs.createWriteStream('destination.txt');

      // Copiar conteúdo de source.txt para destination.txt
      src.pipe(dst);

      // Fechar arquivos após concluir a cópia
      src.on('end', () => {
        src.close();
        dst.close();
      });
    
  

Se você ler este código linha por linha, pode deduzir o que ele faz em termos gerais. Embora aqui seja necessário experiência e prática. Mais adiante, este código parecerá familiar e compreensível.

1.2. Projeto do programa

Projetar um programa é uma arte. É simples e complicado ao mesmo tempo. Simples, porque não há leis rígidas: tudo o que não é proibido é permitido. E complicado também por essa razão: há muitas formas de fazer algo, e não é fácil encontrar a melhor.

Projetar um programa é como escrever um livro. Por um lado, você simplesmente escreve letras, palavras, frases. Por outro lado, importa o enredo, o caráter dos personagens, os conflitos internos, o estilo de narração, a intriga etc.

O mais importante é entender para quem você está escrevendo código. E você escreve código para outros programadores.

O desenvolvimento de qualquer produto é a implementação de mudanças: adicionar aqui, remover ali, remodelar lá. E assim, com pequenas iterações, nascem projetos grandes, enormes e gigantescos.

O requisito principal para o código é ele deve ser compreensível para outros programadores. Código errado, mas compreensível pode ser corrigido. Código correto e incompreensível não pode ser melhorado. Só resta jogá-lo fora.

Então, como escrever um código bom e compreensível?

Para isso, você precisa fazer três coisas:

• Escrever código bom e compreensível dentro dos métodos — o mais fácil
• Decidir quais entidades devem estar no programa
• Dividir corretamente o programa em partes lógicas

O que está por trás desses conceitos?

Escrever código bom dentro dos métodos

Se você tem pelo menos um nível básico de inglês, pode ter notado como às vezes o código é fácil de ler — como frases em inglês:

• class Cat extends Pet — classe Cat estende a classe Pet
• while (stream) — enquanto o fluxo não estiver vazio ...
• a < b ? a : b — se a for menor que b, retorna a, caso contrário, retorna b

Isso é feito propositalmente. JavaScript é uma das poucas linguagens em que é fácil escrever código autodescritivo: um código que seja compreensível sem comentários. Em um bom código em JavaScript, muitos métodos são lidos como sentenças em inglês.

Sua tarefa ao escrever o código é também torná-lo o mais simples e conciso possível. Apenas pense sobre o quanto seu código será fácil de ler, e você começará a se mover na direção certa.

No JavaScript, é comum escrever código de fácil leitura. É desejável que cada método caiba inteiro na tela (comprimento do método — 20-30 linhas). Isso é a norma para toda a comunidade JavaScript. Se o código puder ser melhorado, ele deve ser melhorado.

A melhor maneira de aprender a escrever um bom código é a prática constante. Escreva muito código, estude o código de outras pessoas, peça a programadores mais experientes que façam uma revisão do seu código. E lembre-se de que no momento em que você disser a si mesmo "está bom assim", seu desenvolvimento vai parar.

Decidir quais entidades devem estar no programa

Você precisa escrever um código que seja compreensível para outros programadores. Se 9 de 10 programadores ao projetar um programa criarem classes A, B e C, você também precisa criar em seu programa as classes A, B, e C. Você deve escrever um código que seja compreensível para os outros.

Código excelente, funcional, rápido e não convencional é um código ruim.

Você precisa estudar projetos de outras pessoas: é a melhor, mais rápida e mais fácil maneira de absorver toda a sabedoria, que foi acumulada por décadas na indústria de TI.

E, a propósito, você já tem um ótimo projeto em mãos, popular e bem documentado — React. Comece por ele.

Analise as classes e estruturas de classes. Pense por que alguns métodos são feitos estáticos e outros não. Por que os métodos têm esses parâmetros e não outros. Por que esses métodos, por que as classes são nomeadas assim e estão localizadas nesses pacotes.

Quando você começar a entender as respostas para todas essas perguntas, será capaz de escrever um código que os outros entenderão.

No entanto, quero avisá-lo contra a análise do código nos métodos D3.js. O código de muitos métodos foi reescrito com o objetivo de maximizar a velocidade de operação — sua legibilidade está em dúvida.

Dividir corretamente o programa em partes lógicas

Qualquer programa geralmente é dividido em partes ou módulos. Cada parte é responsável por seu aspecto do programa.

O computador tem uma unidade de sistema, monitor, teclados, e tudo isso são partes separadas e pouco dependentes. Além disso, sua interação é padronizada: USB, HDMI e etc. No entanto, se você derramar café no teclado, pode simplesmente lavá-lo na torneira, secar e usá-lo novamente.

Mas o notebook é um exemplo de arquitetura monolítica: as partes lógicas existem, mas estão integradas de forma muito mais intensa. Em um Macbook Pro, para limpar o teclado, você precisa desmontar metade do notebook. E derramar café no notebook é motivo para encomendar um novo. Apenas não café.

1.3 Criando suas próprias classes

Você ainda está aprendendo a programar, então precisa começar pequeno — aprender a criar suas próprias classes.

Você, é claro, já as criou, mas precisa aprender a entender quais classes devem existir no programa, como elas devem ser chamadas, quais métodos devem ter. E como elas devem interagir umas com as outras.

Lista de entidades

Se você não sabe por onde começar, comece do início.

No início do projeto de um programa, você pode simplesmente listar em um papel as entidades (objetos) que devem existir no programa. E então programá-los com o seguinte princípio: cada entidade — uma classe separada.

Exemplo

Digamos que você quer criar um jogo de xadrez. Você precisará de entidades como: tabuleiro de xadrez e 6 tipos de peças. As peças movem-se de maneiras diferentes, têm diferentes valores — logicamente, essas são classes separadas. E na verdade, no começo, quanto mais classes, melhor.

Encontrar um programador iniciante que, em vez de dois classes, escreveria dez — é uma grande raridade. Agora, em vez de dez escrever dois, ou até um — isso os iniciantes adoram. Então, mais classes, senhores programadores. E seu código se tornará mais compreensível para todos, exceto, talvez, para você 😛

Xadrez

Digamos que decidimos escrever classes para xadrez: como essas classes pareceriam?

O tabuleiro de xadrez é simplesmente uma matriz de 8x8? Melhor fazer uma classe separada para ele, que internamente armazena uma referência para a matriz. Então, na classe "tabuleiro de xadrez", você poderá adicionar muitos métodos úteis, que, por exemplo, verificam se uma casa está vazia ou ocupada.

Em geral, no início você sempre pode se basear no princípio: O programa tem Entidades diferentes, e a Entidade tem tipo. Esse tipo é a classe.