React e TypeScript: As Partes Boas ❤️
Published: 2020-09-17 01:09:00

Comecei a usar o [TypeScript](https://www.typescriptlang.org/) com [React](https://reactjs.org/) e, depois de um tempo, aprendendo e usando eles juntos. É assim que me sinto:

https://twitter.com/tejaskumar_/status/1038372714170470400

Eu não podia acreditar o quanto meu DX melhorou. Vou deixar para vocês os principais recursos de que mais gosto, então espero que vocês se sintam animados para dar uma chance 😃!

## Isenção de responsabilidade ⚠️

Esta não é uma introdução ao TypeScript para iniciantes, você precisa saber pelo menos como usar [Interfaces](https://www.typescriptlang.org/docs/handbook/interfaces.html) , no entanto, no final do artigo, vou apresentar uma lista de excelentes recursos que achei muito úteis. A maneira mais rápida de obter o React + TypeScript instalado e funcionando é:  

```
$ npx create-react-app my-app --template typescript

# ou

$ yarn create react-app my-app --template typescript
```

## TLDR;

Prós:

-   Preenchimento de código e validação de [tipo](https://github.com/DefinitelyTyped/DefinitelyTyped) com [definições de tipo](https://github.com/DefinitelyTyped/DefinitelyTyped) .
-   Ótima comunidade e recursos de aprendizagem.

Contras:

-   A sintaxe do TypeScript e conceitos como [Generics](https://ts.chibicode.com/generics/) podem ser difíceis de entender.

# Índice

- IntelliSense
- Declarações de tipo
- Validação de tipo
- Ganchos
- ~~As partes ruins~~ ou Trade-offs ⚖️
- Recursos
- Conclusão

## IntelliSense
Eu uso o [VSCode](https://code.visualstudio.com/) e um de seus melhores recursos é o [IntelliSense](https://code.visualstudio.com/docs/editor/intellisense) (AKA Code Completion), o TypeScript tira proveito disso.   Digamos que temos um componente `List` e declaramos a Interface `Props`, neste caso um prop `labels`, um array de strings:

```ts
// List.tsx
import React from 'react';

interface Props {
  labels: string[]
}

// Dizemos ao TypeScript o tipo de parâmetro
// + Object Destructuring 👇
function List({ labels }: Props): React.Element {
  return (
    <ul>
      { labels.map((label, index) => {
        <li key={index}>{label}</li>
      )}
    </ul>
  );
}

const strings = ['React', 'TypeScript', '❤️'];
<List labels={strings}/>
```

Com isso nós temos:

[  
![IntelliSense](https://i.giphy.com/media/WOg7qdA8bRrWutWH9Z/giphy.gif)](https://i.giphy.com/media/WOg7qdA8bRrWutWH9Z/giphy.gif)

Se [digitarmos](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) `labels.` dentro de `List`, obtemos o [autocompletar](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) com métodos e atributos de `Array.prototype`, neste caso [Array.prototype.forEach ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) e, em seguida, dentro da função `callback`, obtemos todos os métodos e atributos `String.prototype`, neste exemplo [Array.prototype.toUpperCase ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase) .  

O VSCode é escrito em TypeScript, possui definições de tipo integradas para Native Objects e a melhor parte? Podemos declarar nossos próprios tipos, e a maioria das bibliotecas que usamos já vem com seus próprios arquivos de definição de tipo 😃!  

O que nos leva ao próximo grande recurso.

## Definições de tipo

A comunidade TypeScript é incrível, eles criaram um enorme repositório centralizado de arquivos de definições de tipo de alta qualidade:

https://github.com/DefinitelyTyped/DefinitelyTyped

A maioria das bibliotecas mantém seus arquivos de declaração de tipo neste repositório, e às vezes temos que instalá-los de forma independente, no [site oficial](https://www.typescriptlang.org/dt/search?search=) podemos pesquisar e encontrar instruções para instalá-los, no caso do React, por exemplo:  

```
$ yarn add @types/react --save-dev
```

Como podemos usá-los?  

```ts
import React from 'react';

interface Props {
  labels: string[]
}

function List({ labels }: Props): React.Element {
  const styles: React: React.CSSProperties = {
    backgroundColor: 'blue'
  }
  // ...
}

```

Digamos que queremos escrever algum CSS embutido, neste caso podemos usar a definição de tipo embutida do React `React.CSSProperties`, ela nos mostrará um erro se escrevermos um erro de digitação `backgroundKolor` e obteremos o preenchimento de código para as propriedades 😁.  

E também podemos ver o [código-fonte](https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/react) para nos acostumarmos a ler e escrever tipos.  

Já aprendemos como tirar proveito das definições de tipo para obter o preenchimento de código, mas agora aprenderemos outro recurso poderoso que vem com eles.

## Validação de tipo

E se não passarmos no tipo de prop correto ou se não passarmos nada?  

```ts
interface Props {
  labels: string[]
}

function List({ labels }: Props) {
 // ...
}

const strings = ['React', 'TypeScript', '❤️'];
const numbers: number[] = [1, 2, 3];

// 1) Passamos um array de números
<List labels={numbers} />
// 2) Não passamos nada
<List />

```

Em ambos os casos, obtemos um Erro 🚫:  
[![Texto alternativo](https://res.cloudinary.com/practicaldev/image/fetch/s--V7Lmj1MI--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev-to-uploads.s3.amazonaws.com/i/rqjue2d91becfl70jgx6.png)](https://res.cloudinary.com/practicaldev/image/fetch/s--V7Lmj1MI--/c_limit%2Cf_auto%2Cfl_progressive%2Cq_auto%2Cw_880/https://dev-to-uploads.s3.amazonaws.com/i/rqjue2d91becfl70jgx6.png)

Esses erros são claros, eles nos dizem o que é `type error`, onde isso `declaration` foi feito, se a prop é realmente necessária, e isso se aplica também às funções (embora os componentes do React sejam apenas funções 😉).  

O compilador TypeScript não ficará feliz até que passemos os parâmetros corretos, isso é útil para ver possíveis bugs à frente, mesmo antes de compilar o código e verificar o navegador.

**E como fica o [prop-types](https://reactjs.org/docs/typechecking-with-proptypes.html)?**

Sim, podemos obter a mesma validação usando `prop-types`:  

```ts
import React from 'react';
import PropTypes from 'prop-types';

function List({ labels }) {
  // ...
}

List.propTypes = {
  labels: PropTypes.arrayOf(PropTypes.string).isRequired
}

```

No entanto, como `prop-types` verifica nosso código durante a execução, temos que compilá-lo primeiro, ver o erro real no console e, também, essa validação só acontece no modo de desenvolvimento 😟, enquanto o TypeScript analisa nosso código estaticamente.

## Hooks

Quando se trata de [React Hooks](https://reactjs.org/docs/hooks-intro.html) , `useState`por exemplo, o TypeScript pode ser muito útil, especialmente com validações de tipo.  

```ts
function Counter() {
  // usamos a sintaxe <> para declarar o tipo
  const [counter, setCounter] = useState<number>(0);
  const add = () => {
    // isso irá retornar um erro 😱
    setCounter('string');
  }
  return(
    <div>
      <button onClick={add}>+</button>
      {counter}
    </div>
  );
}

```

Dessa forma, garantimos que sempre que atualizamos o `state`, o tipo de valor será correto, isso pode nos poupar horas de depuração e dores de cabeça.

## As partes ruins. 🤐 Trade-offs

Aprendemos como o TypeScript pode beneficiar toda a equipe quando se trata de escrever componentes, vamos imaginar que escrevemos nossa (idealmente) biblioteca de componentes reutilizáveis ​​com tipos bem definidos e nosso colega importa um deles, eles verão de antemão:

-   Tipos de props e se são necessários ou não.
-   Autocompletar do código para nomes de prop.

Isso pode nos poupar tempo ao navegar pelo código-fonte para garantir que passamos os dados corretos para cada componente.  
Mas também sabemos que em Desenvolvimento de Software não existe bala de prata. Cada ferramenta que escolhemos vem com uma compensação, no caso do TypeScript, é claro que existem algumas:

### Ler TypeScript pode ser difícil:

```ts
interface Array<T> {
  concat(...items: Array<T[] | T>): T[];
  reduce<U>(
    callback: (state: U, element: T, index: number, array: T[]) => U,
    firstState?: U
  ): U;
  // ···
}
```

Mas não se preocupe, eu peguei este trecho deste [ótimo artigo](https://2ality.com/2018/04/type-notation-typescript.html) que explica todos os detalhes, aquele exemplo foi realmente confuso para mim no início.

### Alguns conceitos podem ser complicados de entender:

-   Interfaces
-   Genéricos
-   Interfaces vs Tipos

Esses novos conceitos (especialmente se os membros de nossa equipe não estão acostumados com eles) podem trazer mais dúvidas e confusão. 

Claro que podemos enfrentá-los, depende apenas da experiência dos membros da nossa equipe, do tempo disponível e do desejo de aprender coisas novas.  

Este artigo reflete a ideia que venho pensando há algum tempo e é provável que seja o meu próximo tópico de postagem `everything in Software Development is a trade-off`.

# Recursos

Estes são os melhores recursos que me ajudaram a entender e amar o TypeScript:

- [Understanding TypeScript’s type notation](https://2ality.com/2018/04/type-notation-typescript.html)
- https://github.com/typescript-cheatsheets/react
- [TypeScript Tutorial for JS Programmers Who Know How to Build a Todo App](https://ts.chibicode.com/todo/)
- [TypeScript Generics for People Who Gave Up on Understanding Generics](https://ts.chibicode.com/generics/)

# Conclusão

[![responsabilidade](https://i.giphy.com/media/MCZ39lz83o5lC/giphy.gif)](https://i.giphy.com/media/MCZ39lz83o5lC/giphy.gif)  

O TypeScript vem com muitos benefícios e restrições, mas nosso contexto (equipe, prioridades, objetivos) pode definir se podemos obter mais vantagens do que desvantagens e tornar nossas vidas mais fáceis!  

Quando se trata de aplicativos de grande escala, e especialmente se estivermos construindo uma arquitetura à prova de balas ou Design de Sistema, o esforço compensa, podemos escrever código menos sujeito a bugs e fornecer recursos mais rápidos e seguros.

Obrigado pela leitura, se você achou este artigo útil, siga-me no [Twitter](https://twitter.com/muydiego) e me diga o que você achou!

Boa codificação!

# Créditos

- [# React + TypeScript ❤️: The good parts ⚡](https://dev.to/diemax/react-typescript-the-good-parts-428f), escrito originalmente por [Diego Maximiliano](https://twitter.com/MuyDiego).

---

**Adição do tradutor**: Aqui listo alguns artigos e traduções de minha autoria que podem te ajudar na sua jornada no TypeScript:

- https://medium.com/@oieduardorabelo/typescript-se-divertindo-com-tipos-avan%C3%A7ados-e5cb2aeb65eb
- https://medium.com/@oieduardorabelo/typescript-18-dicas-e-padr%C3%B5es-para-seu-c%C3%B3digo-b63f492a42cd
- https://medium.com/@oieduardorabelo/typescript-folha-de-dicas-e02a7c793139
- https://medium.com/@oieduardorabelo/typescript-o-guia-definitivo-1a63b04259cc
- https://medium.com/@oieduardorabelo/typescript-guia-para-declarac%CC%A7o%CC%83es-de-tipos-de-ambiente-7e54f070e5a6
- https://medium.com/@oieduardorabelo/typescript-entendendo-a-nota%C3%A7%C3%A3o-de-tipos-9e8c1c89ef62
- https://dev.to/oieduardorabelo/typescript-generics-para-pessoas-que-desistiram-de-entender-generics-3fem
- https://dev.to/oieduardorabelo/typescript-entendendo-generics-por-completo-38j7
- https://dev.to/oieduardorabelo/typescript-imutabilidade-em-tempo-de-compilacao-em-typescript-28k9
- https://dev.to/oieduardorabelo/typescript-declaracoes-const-em-expressoes-literais-545g
- https://dev.to/oieduardorabelo/typescript-novidades-que-voce-nao-conhecia-22cl
- https://dev.to/oieduardorabelo/typescript-tecnicas-de-programacao-funcional-2jod
- https://dev.to/oieduardorabelo/typescript-os-5-mandamentos-ao-usar-typescript-2dmp