From ed799e05e773946cd5fbc010593fa8f5a4b1cafc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Renato=20B=C3=B6hler?= <renato.bohler@gmail.com>
Date: Sat, 9 Feb 2019 00:48:46 -0200
Subject: [PATCH 01/54] translate React API Reference

---
 content/docs/reference-react.md | 162 ++++++++++++++++----------------
 1 file changed, 81 insertions(+), 81 deletions(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index d506a1ad3..731138429 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -13,35 +13,35 @@ redirect_from:
   - "docs/top-level-api-zh-CN.html"
 ---
 
-`React` is the entry point to the React library. If you load React from a `<script>` tag, these top-level APIs are available on the `React` global. If you use ES6 with npm, you can write `import React from 'react'`. If you use ES5 with npm, you can write `var React = require('react')`.
+`React` é o ponto de entrada da biblioteca React. Se você carrega o React a partir de uma *tag* `<script>`, estas *API*s *top-level* estarão disponíveis no `React` global. Se você usa ES6 com npm, você pode escrever `import React from 'react'`. Se você usa ES5 com npm, você pode escrever `var React = require('react')`.
 
-## Overview {#overview}
+## Visão Geral {#overview}
 
-### Components {#components}
+### Componentes {#components}
 
-React components let you split the UI into independent, reusable pieces, and think about each piece in isolation. React components can be defined by subclassing `React.Component` or `React.PureComponent`.
+Componentes React permitem que você divida a UI em pedaços independentes e reutilizáveis para pensar em cada pedaço isoladamente. Componentes React podem ser definidos ao estender `React.Component` ou `React.PureComponent`.
 
  - [`React.Component`](#reactcomponent)
  - [`React.PureComponent`](#reactpurecomponent)
 
-If you don't use ES6 classes, you may use the `create-react-class` module instead. See [Using React without ES6](/docs/react-without-es6.html) for more information.
+Se você não utiliza classes do ES6, você pode usar o módulo `create-react-class`. Veja [Usando React sem ES6](/docs/react-without-es6.html) para mais informações.
 
-React components can also be defined as functions which can be wrapped:
+Componentes React também podem ser definidos como funções que podem ser envoltas:
 
 - [`React.memo`](#reactmemo)
 
-### Creating React Elements {#creating-react-elements}
+### Criando Elementos React {#creating-react-elements}
 
-We recommend [using JSX](/docs/introducing-jsx.html) to describe what your UI should look like. Each JSX element is just syntactic sugar for calling [`React.createElement()`](#createelement). You will not typically invoke the following methods directly if you are using JSX.
+Nós recomendamos [utilizar JSX](/docs/introducing-jsx.html) para descrever como sua UI deve se parecer. Cada elemento JSX é somente uma maneira alternativa de utilizar [`React.createElement()`](#createelement). Você tipicamente não vai utilizar os métodos seguintes caso esteja usando JSX.
 
 - [`createElement()`](#createelement)
 - [`createFactory()`](#createfactory)
 
-See [Using React without JSX](/docs/react-without-jsx.html) for more information.
+Veja [Usando React sem JSX](/docs/react-without-jsx.html) para mais informações.
 
-### Transforming Elements {#transforming-elements}
+### Transformando Elementos {#transforming-elements}
 
-`React` provides several APIs for manipulating elements:
+`React` provê várias *API*s para manipulação de elementos:
 
 - [`cloneElement()`](#cloneelement)
 - [`isValidElement()`](#isvalidelement)
@@ -49,7 +49,7 @@ See [Using React without JSX](/docs/react-without-jsx.html) for more information
 
 ### Fragments {#fragments}
 
-`React` also provides a component for rendering multiple elements without a wrapper.
+`React` também provê um componente para renderizar múltiplos elementos sem um invólucro.
 
 - [`React.Fragment`](#reactfragment)
 
@@ -60,20 +60,20 @@ See [Using React without JSX](/docs/react-without-jsx.html) for more information
 
 ### Suspense {#suspense}
 
-Suspense lets components "wait" for something before rendering. Today, Suspense only supports one use case: [loading components dynamically with `React.lazy`](/docs/code-splitting.html#reactlazy). In the future, it will support other use cases like data fetching.
+*Suspense* permite que componentes "esperem" por algo antes de renderizar. Atualmente, *Suspense* suporta somente somente um caso de uso: [carregando componentes dinamicamente com `React.lazy`](/docs/code-splitting.html#reactlazy). Futuramente, ele suportará outros casos de uso, como busca de dados.
 
 - [`React.lazy`](#reactlazy)
 - [`React.Suspense`](#reactsuspense)
 
 ### Hooks {#hooks}
 
-*Hooks* are a new addition in React 16.8. They let you use state and other React features without writing a class. Hooks have a [dedicated docs section](/docs/hooks-intro.html) and a separate API reference:
+*Hooks* são uma novidade no React 16.8. Eles permitem que você utilize estado e outras funcionalidades do React sem ter que escrever uma classe para isso. *Hooks* possuem uma [seção dedicada na documentação](/docs/hooks-intro.html) e uma referência da *API* separada:
 
-- [Basic Hooks](/docs/hooks-reference.html#basic-hooks)
+- [*Hooks* Básicos](/docs/hooks-reference.html#basic-hooks)
   - [`useState`](/docs/hooks-reference.html#usestate)
   - [`useEffect`](/docs/hooks-reference.html#useeffect)
   - [`useContext`](/docs/hooks-reference.html#usecontext)
-- [Additional Hooks](/docs/hooks-reference.html#additional-hooks)
+- [*Hooks* Adicionais](/docs/hooks-reference.html#additional-hooks)
   - [`useReducer`](/docs/hooks-reference.html#usereducer)
   - [`useCallback`](/docs/hooks-reference.html#usecallback)
   - [`useMemo`](/docs/hooks-reference.html#usememo)
@@ -84,11 +84,11 @@ Suspense lets components "wait" for something before rendering. Today, Suspense
 
 * * *
 
-## Reference {#reference}
+## Referência {#reference}
 
 ### `React.Component` {#reactcomponent}
 
-`React.Component` is the base class for React components when they are defined using [ES6 classes](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Classes):
+`React.Component` é a classe base para componentes React quando eles são definidos usando [classes ES6](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Classes):
 
 ```javascript
 class Greeting extends React.Component {
@@ -98,21 +98,21 @@ class Greeting extends React.Component {
 }
 ```
 
-See the [React.Component API Reference](/docs/react-component.html) for a list of methods and properties related to the base `React.Component` class.
+Veja a [referência da *API* para React.Component](/docs/react-component.html) para uma lista de métodos e propriedades relacionadas à classe base `React.Component`.
 
 * * *
 
 ### `React.PureComponent` {#reactpurecomponent}
 
-`React.PureComponent` is similar to [`React.Component`](#reactcomponent). The difference between them is that [`React.Component`](#reactcomponent) doesn't implement [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate), but `React.PureComponent` implements it with a shallow prop and state comparison. 
+`React.PureComponent` é similar a [`React.Component`](#reactcomponent). A diferença entre eles é que [`React.Component`](#reactcomponent) não implementa [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate), enquanto `React.PureComponent` a implementa com uma comparação superficial de props e state.
 
-If your React component's `render()` function renders the same result given the same props and state, you can use `React.PureComponent` for a performance boost in some cases.
+Se o método `render()` do seu componente React renderiza o mesmo resultado dados os mesmos props e state, você pode usar `React.PureComponent` para um aumento no desempenho em alguns casos.
 
-> Note
+> Nota
 >
-> `React.PureComponent`'s `shouldComponentUpdate()` only shallowly compares the objects. If these contain complex data structures, it may produce false-negatives for deeper differences. Only extend `PureComponent` when you expect to have simple props and state, or use [`forceUpdate()`](/docs/react-component.html#forceupdate) when you know deep data structures have changed. Or, consider using [immutable objects](https://facebook.github.io/immutable-js/) to facilitate fast comparisons of nested data.
+> O método `shouldComponentUpdate()` de `React.PureComponent` compara os objetos apenas superficialmente. Se eles contiverem estruturas de dados complexas, isto pode causar falso-negativos para diferenças mais profundas. Estenda `PureComponent` quando você espera possuir props e state simples, ou então use [`forceUpdate()`](/docs/react-component.html#forceupdate) quando você souber que ocorreram mudanças profundas na estrutura de dados.
 >
-> Furthermore, `React.PureComponent`'s `shouldComponentUpdate()` skips prop updates for the whole component subtree. Make sure all the children components are also "pure".
+> Além disso, o método `shouldComponentUpdate()` de `React.PureComponent` pula atualizações de prop para toda a subárvore do componente. Esteja certo de que todos seus componentes filho são também são "puros".
 
 * * *
 
@@ -120,35 +120,35 @@ If your React component's `render()` function renders the same result given the
 
 ```javascript
 const MyComponent = React.memo(function MyComponent(props) {
-  /* render using props */
+  /* renderize usando props */
 });
 ```
 
-`React.memo` is a [higher order component](/docs/higher-order-components.html). It's similar to [`React.PureComponent`](#reactpurecomponent) but for function components instead of classes.
+`React.memo` é um *[higher order component](/docs/higher-order-components.html)*. É similar a [`React.PureComponent`](#reactpurecomponent), mas para *function components* ao invés de classes.
 
-If your function component renders the same result given the same props, you can wrap it in a call to `React.memo` for a performance boost in some cases by memoizing the result. This means that React will skip rendering the component, and reuse the last rendered result.
+Se seu *function component* renderiza o mesmo resultado dados os mesmos props, você pode envolver nele uma chamada para `React.memo` para um aumento no desempenho em alguns casos, através da memoização do resultado. Isto significa que o React vai pular a renderização do componente e reutilizar o último resultado renderizado.
 
-By default it will only shallowly compare complex objects in the props object. If you want control over the comparison, you can also provide a custom comparison function as the second argument.
+Por padrão, ele irá comparar apenas superficialmente os objetos nos props. Se você quiser controle sob a comparação, você também pode prover uma função customizada de comparação como segundo argumento.
 
 ```javascript
 function MyComponent(props) {
-  /* render using props */
+  /* renderize usando props */
 }
 function areEqual(prevProps, nextProps) {
   /*
-  return true if passing nextProps to render would return
-  the same result as passing prevProps to render,
-  otherwise return false
+  retorne true se passar nextProps renderizaria o mesmo
+  resultado se passasse prevProps,
+  do contrário, retorne false
   */
 }
 export default React.memo(MyComponent, areEqual);
 ```
 
-This method only exists as a **[performance optimization](/docs/optimizing-performance.html).** Do not rely on it to "prevent" a render, as this can lead to bugs.
+Este método somente existe como uma **[otimização de performance](/docs/optimizing-performance.html).** Não conte com ele para "prevenir" uma renderização, pois isso pode levar a *bugs*.
 
-> Note
+> Nota
 >
-> Unlike the [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate) method on class components, the `areEqual` function returns `true` if the props are equal and `false` if the props are not equal. This is the inverse from `shouldComponentUpdate`.
+> Ao contrário do método [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate) de *class components*, a função `areEqual` retorna `true` se os props são iguais e `false` se os props não são iguais. É o inverso de `shouldComponentUpdate`.
 
 * * *
 
@@ -162,9 +162,9 @@ React.createElement(
 )
 ```
 
-Create and return a new [React element](/docs/rendering-elements.html) of the given type. The type argument can be either a tag name string (such as `'div'` or `'span'`), a [React component](/docs/components-and-props.html) type (a class or a function), or a [React fragment](#reactfragment) type.
+Cria e retorna um novo [elemento React](/docs/rendering-elements.html) do tipo dado. O argumento `type` pode ser uma *string* contendo o *tag name* (como, por exemplo, `'div'` ou `'span'`), um [componente React](/docs/components-and-props.html) (uma classe ou uma função), ou um [React *fragment*](#reactfragment).
 
-Code written with [JSX](/docs/introducing-jsx.html) will be converted to use `React.createElement()`. You will not typically invoke `React.createElement()` directly if you are using JSX. See [React Without JSX](/docs/react-without-jsx.html) to learn more.
+Código escrito utilizando [JSX](/docs/introducing-jsx.html) será convertido para utilizar `React.createElement()`. Você tipicamente não invocará `React.createElement()` diretamente se você está usando JSX. Veja [React sem JSX](/docs/react-without-jsx.html) para aprender mais.
 
 * * *
 
@@ -178,17 +178,17 @@ React.cloneElement(
 )
 ```
 
-Clone and return a new React element using `element` as the starting point. The resulting element will have the original element's props with the new props merged in shallowly. New children will replace existing children. `key` and `ref` from the original element will be preserved.
+Clona e retorna um novo elemento React usando `element` como ponto de partida. O elemento resultante terá os props do elemento original, com os novos props mesclados superficialmente. Novos elementos filho substituirão os existentes. `key` e `ref` do elemento original serão preservados.
 
-`React.cloneElement()` is almost equivalent to:
+`React.cloneElement()` é quase equivalente a:
 
 ```js
 <element.type {...element.props} {...props}>{children}</element.type>
 ```
 
-However, it also preserves `ref`s. This means that if you get a child with a `ref` on it, you won't accidentally steal it from your ancestor. You will get the same `ref` attached to your new element.
+No entanto, ele também preserva `ref`s. Isto significa que se você possui um elemento filho com um `ref` nele, você não o roubará acidentalmente do seu antepassado. Você terá o mesmo `ref` ligado ao seu novo elemento.
 
-This API was introduced as a replacement of the deprecated `React.addons.cloneWithProps()`.
+Esta *API* foi introduzida como uma reposição ao `React.addons.cloneWithProps()`, que foi descontinuado.
 
 * * *
 
@@ -197,12 +197,11 @@ This API was introduced as a replacement of the deprecated `React.addons.cloneWi
 ```javascript
 React.createFactory(type)
 ```
+Retorna uma função que produz elementos React de um dado tipo. Assim como em [`React.createElement()`](#createElement), o argumento `type` pode ser uma *string* contendo o *tag name* (como, por exemplo, `'div'` ou `'span'`), um [componente React](/docs/components-and-props.html) (uma classe ou uma função), ou um [React *fragment*](#reactfragment).
 
-Return a function that produces React elements of a given type. Like [`React.createElement()`](#createElement), the type argument can be either a tag name string (such as `'div'` or `'span'`), a [React component](/docs/components-and-props.html) type (a class or a function), or a [React fragment](#reactfragment) type.
+Este *helper* é considerado legado, e nós encorajamos você a utilizar JSX ou `React.createElement()` diretamente como alternativa.
 
-This helper is considered legacy, and we encourage you to either use JSX or use `React.createElement()` directly instead.
-
-You will not typically invoke `React.createFactory()` directly if you are using JSX. See [React Without JSX](/docs/react-without-jsx.html) to learn more.
+Você tipicamente não invocará `React.createFactory()` diretamente se estiver utilizando JSX. Veja [React sem JSX](/docs/react-without-jsx.html) para aprender mais.
 
 * * *
 
@@ -212,13 +211,13 @@ You will not typically invoke `React.createFactory()` directly if you are using
 React.isValidElement(object)
 ```
 
-Verifies the object is a React element. Returns `true` or `false`.
+Verifica se o objeto é um elemento React. Retorna `true` ou `false`.
 
 * * *
 
 ### `React.Children` {#reactchildren}
 
-`React.Children` provides utilities for dealing with the `this.props.children` opaque data structure.
+`React.Children` provê utilitários para lidar com a estrutura de dados opaca `this.props.children`.
 
 #### `React.Children.map` {#reactchildrenmap}
 
@@ -226,11 +225,11 @@ Verifies the object is a React element. Returns `true` or `false`.
 React.Children.map(children, function[(thisArg)])
 ```
 
-Invokes a function on every immediate child contained within `children` with `this` set to `thisArg`. If `children` is an array it will be traversed and the function will be called for each child in the array. If children is `null` or `undefined`, this method will return `null` or `undefined` rather than an array.
+Invoca uma função em cada elemento filho imediato contido em `children` com `this` definido para `thisArg`. Se `children` for um *array*, a função sará chamada para cada filho no *array*. Se `children` for `null` ou `undefined`, este método retornará `null` ou `undefined` ao invés de um *array*.
 
-> Note
+> Nota
 >
-> If `children` is a `Fragment` it will be treated as a single child and not traversed.
+> Se `children` for um `Fragment` ele será tratado como um elemento filho único.
 
 #### `React.Children.forEach` {#reactchildrenforeach}
 
@@ -238,7 +237,7 @@ Invokes a function on every immediate child contained within `children` with `th
 React.Children.forEach(children, function[(thisArg)])
 ```
 
-Like [`React.Children.map()`](#reactchildrenmap) but does not return an array.
+Igual a [`React.Children.map()`](#reactchildrenmap), mas não retorna um *array*.
 
 #### `React.Children.count` {#reactchildrencount}
 
@@ -246,7 +245,7 @@ Like [`React.Children.map()`](#reactchildrenmap) but does not return an array.
 React.Children.count(children)
 ```
 
-Returns the total number of components in `children`, equal to the number of times that a callback passed to `map` or `forEach` would be invoked.
+Retorna o número total de componentes em `children`, igual ao número de vezes que o *callback* passado para `map` ou `forEach` seria invocado.
 
 #### `React.Children.only` {#reactchildrenonly}
 
@@ -254,11 +253,11 @@ Returns the total number of components in `children`, equal to the number of tim
 React.Children.only(children)
 ```
 
-Verifies that `children` has only one child (a React element) and returns it. Otherwise this method throws an error.
+Verifica que `children` possui apenas um elemento filho (um elemento React) e o retorna. Caso contrário, este método lança um erro.
 
-> Note:
+> Nota
 >
->`React.Children.only()` does not accept the return value of [`React.Children.map()`](#reactchildrenmap) because it is an array rather than a React element.
+> `React.Children.only()` não aceita o valor retornado de [`React.Children.map()`](#reactchildrenmap) pois este é um array ao invés de um elemento React.
 
 #### `React.Children.toArray` {#reactchildrentoarray}
 
@@ -266,17 +265,17 @@ Verifies that `children` has only one child (a React element) and returns it. Ot
 React.Children.toArray(children)
 ```
 
-Returns the `children` opaque data structure as a flat array with keys assigned to each child. Useful if you want to manipulate collections of children in your render methods, especially if you want to reorder or slice `this.props.children` before passing it down.
+Retorna a estrutura de dados opaca `children` como um *flat array* com as chaves atribuídas a cada elemento filho. Útil se você deseja manipular coleções de elementos filhos em seus métodos de renderização, especialmente se você quiser reordenar ou repartir `this.props.children` antes de repassá-los.
 
-> Note:
+> Nota
 >
-> `React.Children.toArray()` changes keys to preserve the semantics of nested arrays when flattening lists of children. That is, `toArray` prefixes each key in the returned array so that each element's key is scoped to the input array containing it.
+> `React.Children.toArray()` altera `key`s para preservar a semântica de *arrays* aninhados quando realizando o *flatten* de listas de elementos filho. Isto é, `toArray` prefixa cada `key` no *array* retornado, de tal modo que o `key` de cada elemento possui o escopo do *array* que o contém.
 
 * * *
 
 ### `React.Fragment` {#reactfragment}
 
-The `React.Fragment` component lets you return multiple elements in a `render()` method without creating an additional DOM element:
+O componente `React.Fragment` permite que você retorne múltiplos elementos num método `render()` sem precisar criar um elemento DOM adicional:
 
 ```javascript
 render() {
@@ -289,59 +288,60 @@ render() {
 }
 ```
 
-You can also use it with the shorthand `<></>` syntax. For more information, see [React v16.2.0: Improved Support for Fragments](/blog/2017/11/28/react-v16.2.0-fragment-support.html).
+Você também pode usar ele com a forma abreviada `<></>`. Para mais informações, veja [React v16.2.0: Suporte Melhorado para *Fragments*](/blog/2017/11/28/react-v16.2.0-fragment-support.html).
 
 
 ### `React.createRef` {#reactcreateref}
 
-`React.createRef` creates a [ref](/docs/refs-and-the-dom.html) that can be attached to React elements via the ref attribute.
+`React.createRef` cria um [`ref`](/docs/refs-and-the-dom.html) que pode ser anexado a elementos React via atributo `ref`.
+
 `embed:16-3-release-blog-post/create-ref-example.js`
 
 ### `React.forwardRef` {#reactforwardref}
 
-`React.forwardRef` creates a React component that forwards the [ref](/docs/refs-and-the-dom.html) attribute it receives to another component below in the tree. This technique is not very common but is particularly useful in two scenarios:
+`React.forwardRef` cria um componente React que encaminha o atributo [`ref`](/docs/refs-and-the-dom.html) que ele recebe para outro componente abaixo na árvore. Esta técnica não é muito comum, mas é particularmente útil nos dois cenários:
 
-* [Forwarding refs to DOM components](/docs/forwarding-refs.html#forwarding-refs-to-dom-components)
-* [Forwarding refs in higher-order-components](/docs/forwarding-refs.html#forwarding-refs-in-higher-order-components)
+* [Encaminhando *refs* para componentes DOM](/docs/forwarding-refs.html#forwarding-refs-to-dom-components)
+* [Encaminhando *refs* em *higher-order-components*](/docs/forwarding-refs.html#forwarding-refs-in-higher-order-components)
 
-`React.forwardRef` accepts a rendering function as an argument. React will call this function with `props` and `ref` as two arguments. This function should return a React node.
+`React.forwardRef` aceita uma função de renderização como argumento. React chamará esta função com `props` e `ref` como seus dois argumentos. Esta função deve retornar um React *node*.
 
 `embed:reference-react-forward-ref.js`
 
-In the above example, React passes a `ref` given to `<FancyButton ref={ref}>` element as a second argument to the rendering function inside the `React.forwardRef` call. This rendering function passes the `ref` to the `<button ref={ref}>` element.
+No exemplo acima, React passa o `ref` dado para o elemento `<FancyButton ref={ref}>` como o segundo argumento para a função de renderização dentro da chamada `React.forwardRef`.
 
-As a result, after React attaches the ref, `ref.current` will point directly to the `<button>` DOM element instance.
+Como resultado, após React anexar o `ref`, `ref.current` irá apontar diretamente para a instância do elemento DOM `<button>`
 
-For more information, see [forwarding refs](/docs/forwarding-refs.html).
+Para mais informações, veja [encaminhando *refs*](/docs/forwarding-refs.html).
 
 ### `React.lazy` {#reactlazy}
 
-`React.lazy()` lets you define a component that is loaded dynamically. This helps reduce the bundle size to delay loading components that aren't used during the initial render.
+`React.lazy()` permite que você defina um componente que é carregado dinamicamente. Isto ajuda a reduzir o tamanho do *bundle*, retardando o carregamento de componentes que não são utilizados durante a renderização inicial.
 
-You can learn how to use it from our [code splitting documentation](/docs/code-splitting.html#reactlazy). You might also want to check out [this article](https://medium.com/@pomber/lazy-loading-and-preloading-components-in-react-16-6-804de091c82d) explaining how to use it in more detail.
+Você pode aprender como utilizar isto em nossa [documentação de *code splitting*](/docs/code-splitting.html#reactlazy). Você pode também querer ver [este artigo](https://medium.com/@pomber/lazy-loading-and-preloading-components-in-react-16-6-804de091c82d) explicando como utilizar em mais detalhe.
 
 ```js
-// This component is loaded dynamically
+// Este componente é carregado dinamicamente
 const SomeComponent = React.lazy(() => import('./SomeComponent'));
 ```
 
-Note that rendering `lazy` components requires that there's a `<React.Suspense>` component higher in the rendering tree. This is how you specify a loading indicator.
+Note que renderizar componentes `lazy` requer que exista um componente `<React.Suspense>` num nível mais alto da árvore de renderização. É assim que você especifica um indicador de carregamento.
 
-> **Note**
+> Nota
 >
-> Using `React.lazy`with dynamic import requires Promises to be available in the JS environment. This requires a polyfill on IE11 and below.
+> Usar `React.lazy` com *import* dinâmico requer que `Promises` estejam disponíveis no ambiente JS. Isto requer um *polyfill* em IE11 e abaixo.
 
 ### `React.Suspense` {#reactsuspense}
 
-`React.Suspense` let you specify the loading indicator in case some components in the tree below it are not yet ready to render. Today, lazy loading components is the **only** use case supported by `<React.Suspense>`:
+`React.Suspense` permite que você especifique o indicador de carregamento em caso de alguns componentes abaixo na árvore ainda não estarem prontos para renderizar. Atualmente, componentes de carregamento *lazy* são o **único** caso de uso suportado por `<React.Suspense>`:
 
 ```js
-// This component is loaded dynamically
+// Este componente é carregado dinamicamente
 const OtherComponent = React.lazy(() => import('./OtherComponent'));
 
 function MyComponent() {
   return (
-    // Displays <Spinner> until OtherComponent loads
+    // Mostra <Spinner> enquanto OtherComponent carrega
     <React.Suspense fallback={<Spinner />}>
       <div>
         <OtherComponent />
@@ -351,10 +351,10 @@ function MyComponent() {
 }
 ```
 
-It is documented in our [code splitting guide](/docs/code-splitting.html#reactlazy). Note that `lazy` components can be deep inside the `Suspense` tree -- it doesn't have to wrap every one of them. The best practice is to place `<Suspense>` where you want to see a loading indicator, but to use `lazy()` wherever you want to do code splitting.
+Isto está documentado em nosso [guia para *code splitting*](/docs/code-splitting.html#reactlazy). Note que componentes `lazy` podem estar em níveis profundos dentro da árvore de `Suspense` -- ele não precisa envolver cada um deles. A melhor prática é colocar `<Suspense>` onde você quer ver um indicador de carregamento, mas utilizar `lazy()` onde você quiser realizar *code splitting*.
 
-While this is not supported today, in the future we plan to let `Suspense` handle more scenarios such as data fetching. You can read about this in [our roadmap](/blog/2018/11/27/react-16-roadmap.html).
+Enquanto isto ainda não é suportado, no futuro nós planejamos permitir que `Suspense` lide com mais cenários como busca de dados. Você pode ler sobre isso em [nosso *roadmap*](/blog/2018/11/27/react-16-roadmap.html).
 
->Note:
+> Nota
 >
->`React.lazy()` and `<React.Suspense>` are not yet supported by `ReactDOMServer`. This is a known limitation that will be resolved in the future.
+> `React.lazy()` e `<React.Suspense>` ainda não são suportados por `ReactDOMServer`. Esta é uma limitação conhecida que será resolvida futuramente.

From afc7a30045ca073ea9b0e45c1be5297efd6f3a15 Mon Sep 17 00:00:00 2001
From: Cezar Augusto <boss@cezaraugusto.net>
Date: Sat, 9 Feb 2019 19:56:05 -0200
Subject: [PATCH 02/54] Update content/docs/reference-react.md

Co-Authored-By: renato-bohler <renato.bohler@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 731138429..66b30af7e 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -19,7 +19,7 @@ redirect_from:
 
 ### Componentes {#components}
 
-Componentes React permitem que você divida a UI em pedaços independentes e reutilizáveis para pensar em cada pedaço isoladamente. Componentes React podem ser definidos ao estender `React.Component` ou `React.PureComponent`.
+Os componentes React permitem que você divida a UI em pedaços independentes e reutilizáveis para pensar em cada pedaço isoladamente. Os componentes em React podem ser definidos ao estender `React.Component` ou `React.PureComponent`.
 
  - [`React.Component`](#reactcomponent)
  - [`React.PureComponent`](#reactpurecomponent)

From c2a1ed6aa8108c227facf9c8b091782390337082 Mon Sep 17 00:00:00 2001
From: Cezar Augusto <boss@cezaraugusto.net>
Date: Sat, 9 Feb 2019 19:56:11 -0200
Subject: [PATCH 03/54] Update content/docs/reference-react.md

Co-Authored-By: renato-bohler <renato.bohler@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 66b30af7e..1756a6c79 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -26,7 +26,7 @@ Os componentes React permitem que você divida a UI em pedaços independentes e
 
 Se você não utiliza classes do ES6, você pode usar o módulo `create-react-class`. Veja [Usando React sem ES6](/docs/react-without-es6.html) para mais informações.
 
-Componentes React também podem ser definidos como funções que podem ser envoltas:
+Os componentes em React também podem ser definidos como funções que podem ser envoltas:
 
 - [`React.memo`](#reactmemo)
 

From b60f5ed89cec3b56e97dd7f6f22c478f7ec6fe3d Mon Sep 17 00:00:00 2001
From: Cezar Augusto <boss@cezaraugusto.net>
Date: Sat, 9 Feb 2019 19:56:25 -0200
Subject: [PATCH 04/54] Update content/docs/reference-react.md

Co-Authored-By: renato-bohler <renato.bohler@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 1756a6c79..676e9c6b4 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -32,7 +32,7 @@ Os componentes em React também podem ser definidos como funções que podem ser
 
 ### Criando Elementos React {#creating-react-elements}
 
-Nós recomendamos [utilizar JSX](/docs/introducing-jsx.html) para descrever como sua UI deve se parecer. Cada elemento JSX é somente uma maneira alternativa de utilizar [`React.createElement()`](#createelement). Você tipicamente não vai utilizar os métodos seguintes caso esteja usando JSX.
+Nós recomendamos [utilizar o JSX](/docs/introducing-jsx.html) para descrever como sua UI deve se parecer. Cada elemento JSX é somente uma maneira alternativa de utilizar o [`React.createElement()`](#createelement). Em geral você não vai utilizar os métodos seguintes caso esteja usando JSX.
 
 - [`createElement()`](#createelement)
 - [`createFactory()`](#createfactory)

From 9afed592fa1ad569e502a09b81e0924207996bcb Mon Sep 17 00:00:00 2001
From: Cezar Augusto <boss@cezaraugusto.net>
Date: Sat, 9 Feb 2019 19:56:34 -0200
Subject: [PATCH 05/54] Update content/docs/reference-react.md

Co-Authored-By: renato-bohler <renato.bohler@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 676e9c6b4..63fe17eab 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -186,7 +186,7 @@ Clona e retorna um novo elemento React usando `element` como ponto de partida. O
 <element.type {...element.props} {...props}>{children}</element.type>
 ```
 
-No entanto, ele também preserva `ref`s. Isto significa que se você possui um elemento filho com um `ref` nele, você não o roubará acidentalmente do seu antepassado. Você terá o mesmo `ref` ligado ao seu novo elemento.
+No entanto, ele também preserva `ref`s. Isto significa que se você possui um elemento filho com um `ref` nele, você não o roubará acidentalmente do seu antecessor. Você terá o mesmo `ref` ligado ao seu novo elemento.
 
 Esta *API* foi introduzida como uma reposição ao `React.addons.cloneWithProps()`, que foi descontinuado.
 

From 1ba1d197b5f3d44c2c6013c41a7a1deb554c149c Mon Sep 17 00:00:00 2001
From: Cezar Augusto <boss@cezaraugusto.net>
Date: Sat, 9 Feb 2019 19:56:57 -0200
Subject: [PATCH 06/54] Update content/docs/reference-react.md

Co-Authored-By: renato-bohler <renato.bohler@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 63fe17eab..dba7314e2 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -30,7 +30,7 @@ Os componentes em React também podem ser definidos como funções que podem ser
 
 - [`React.memo`](#reactmemo)
 
-### Criando Elementos React {#creating-react-elements}
+### Criando Elementos em React {#creating-react-elements}
 
 Nós recomendamos [utilizar o JSX](/docs/introducing-jsx.html) para descrever como sua UI deve se parecer. Cada elemento JSX é somente uma maneira alternativa de utilizar o [`React.createElement()`](#createelement). Em geral você não vai utilizar os métodos seguintes caso esteja usando JSX.
 

From 0753ab67b772501c237cbd2a2aebcd0fe0918e0a Mon Sep 17 00:00:00 2001
From: Cezar Augusto <boss@cezaraugusto.net>
Date: Sat, 9 Feb 2019 19:57:09 -0200
Subject: [PATCH 07/54] Update content/docs/reference-react.md

Co-Authored-By: renato-bohler <renato.bohler@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index dba7314e2..b9e5fde6f 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -41,7 +41,7 @@ Veja [Usando React sem JSX](/docs/react-without-jsx.html) para mais informaçõe
 
 ### Transformando Elementos {#transforming-elements}
 
-`React` provê várias *API*s para manipulação de elementos:
+O `React` provê várias *API*s para manipulação de elementos:
 
 - [`cloneElement()`](#cloneelement)
 - [`isValidElement()`](#isvalidelement)

From c99afea358c38d745ba5bb341fb99c10c0dd0785 Mon Sep 17 00:00:00 2001
From: Cezar Augusto <boss@cezaraugusto.net>
Date: Sat, 9 Feb 2019 19:57:53 -0200
Subject: [PATCH 08/54] Update content/docs/reference-react.md

Co-Authored-By: renato-bohler <renato.bohler@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index b9e5fde6f..fb405a530 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -104,7 +104,7 @@ Veja a [referência da *API* para React.Component](/docs/react-component.html) p
 
 ### `React.PureComponent` {#reactpurecomponent}
 
-`React.PureComponent` é similar a [`React.Component`](#reactcomponent). A diferença entre eles é que [`React.Component`](#reactcomponent) não implementa [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate), enquanto `React.PureComponent` a implementa com uma comparação superficial de props e state.
+`React.PureComponent` é similar a [`React.Component`](#reactcomponent). A diferença entre eles é que o [`React.Component`](#reactcomponent) não implementa o  [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate), enquanto o `React.PureComponent` a implementa com uma comparação superficial de props e state.
 
 Se o método `render()` do seu componente React renderiza o mesmo resultado dados os mesmos props e state, você pode usar `React.PureComponent` para um aumento no desempenho em alguns casos.
 

From f413ef6bdc400ecb4a01fe3f18b9548a844050db Mon Sep 17 00:00:00 2001
From: Cezar Augusto <boss@cezaraugusto.net>
Date: Sat, 9 Feb 2019 19:58:31 -0200
Subject: [PATCH 09/54] Update content/docs/reference-react.md

Co-Authored-By: renato-bohler <renato.bohler@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index fb405a530..1013b804e 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -110,7 +110,7 @@ Se o método `render()` do seu componente React renderiza o mesmo resultado dado
 
 > Nota
 >
-> O método `shouldComponentUpdate()` de `React.PureComponent` compara os objetos apenas superficialmente. Se eles contiverem estruturas de dados complexas, isto pode causar falso-negativos para diferenças mais profundas. Estenda `PureComponent` quando você espera possuir props e state simples, ou então use [`forceUpdate()`](/docs/react-component.html#forceupdate) quando você souber que ocorreram mudanças profundas na estrutura de dados.
+> O método `shouldComponentUpdate()` do `React.PureComponent` compara os objetos apenas superficialmente. Se eles contiverem estruturas de dados complexas, isto pode causar falso-negativos para diferenças mais profundas. Estenda `PureComponent` quando você espera possuir props e state simples, ou então use [`forceUpdate()`](/docs/react-component.html#forceupdate) quando você souber que ocorreram mudanças profundas na estrutura de dados.
 >
 > Além disso, o método `shouldComponentUpdate()` de `React.PureComponent` pula atualizações de prop para toda a subárvore do componente. Esteja certo de que todos seus componentes filho são também são "puros".
 

From 84780548890a069f432ef1ea14d750b49968e02c Mon Sep 17 00:00:00 2001
From: Cezar Augusto <boss@cezaraugusto.net>
Date: Sat, 9 Feb 2019 19:59:20 -0200
Subject: [PATCH 10/54] Update content/docs/reference-react.md

Co-Authored-By: renato-bohler <renato.bohler@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 1013b804e..795961b29 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -318,7 +318,7 @@ Para mais informações, veja [encaminhando *refs*](/docs/forwarding-refs.html).
 
 `React.lazy()` permite que você defina um componente que é carregado dinamicamente. Isto ajuda a reduzir o tamanho do *bundle*, retardando o carregamento de componentes que não são utilizados durante a renderização inicial.
 
-Você pode aprender como utilizar isto em nossa [documentação de *code splitting*](/docs/code-splitting.html#reactlazy). Você pode também querer ver [este artigo](https://medium.com/@pomber/lazy-loading-and-preloading-components-in-react-16-6-804de091c82d) explicando como utilizar em mais detalhe.
+Você pode aprender como utilizar isto em nossa [documentação de *code splitting*](/docs/code-splitting.html#reactlazy). Você pode também querer ver [este artigo](https://medium.com/@pomber/lazy-loading-and-preloading-components-in-react-16-6-804de091c82d) explicando como utilizar mais detalhadamente.
 
 ```js
 // Este componente é carregado dinamicamente

From b7db89fd3c670bd8d6ceb3701a4155ac989a5749 Mon Sep 17 00:00:00 2001
From: Cezar Augusto <boss@cezaraugusto.net>
Date: Sat, 9 Feb 2019 19:59:32 -0200
Subject: [PATCH 11/54] Update content/docs/reference-react.md

Co-Authored-By: renato-bohler <renato.bohler@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 795961b29..117eb8cf1 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -329,7 +329,7 @@ Note que renderizar componentes `lazy` requer que exista um componente `<React.S
 
 > Nota
 >
-> Usar `React.lazy` com *import* dinâmico requer que `Promises` estejam disponíveis no ambiente JS. Isto requer um *polyfill* em IE11 e abaixo.
+> Usar `React.lazy` com *import* dinâmico requer que `Promises` estejam disponíveis no ambiente JS. Isto requer um *polyfill* no IE11 e suas versōes anteriores.
 
 ### `React.Suspense` {#reactsuspense}
 

From 5115ad6531902ee20f6b0fc717cc7a580318c070 Mon Sep 17 00:00:00 2001
From: Cezar Augusto <boss@cezaraugusto.net>
Date: Sat, 9 Feb 2019 19:59:46 -0200
Subject: [PATCH 12/54] Update content/docs/reference-react.md

Co-Authored-By: renato-bohler <renato.bohler@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 117eb8cf1..c3fe66cc1 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -333,7 +333,7 @@ Note que renderizar componentes `lazy` requer que exista um componente `<React.S
 
 ### `React.Suspense` {#reactsuspense}
 
-`React.Suspense` permite que você especifique o indicador de carregamento em caso de alguns componentes abaixo na árvore ainda não estarem prontos para renderizar. Atualmente, componentes de carregamento *lazy* são o **único** caso de uso suportado por `<React.Suspense>`:
+`React.Suspense` permite que você especifique o indicador de carregamento em caso de alguns componentes abaixo na árvore ainda não estarem prontos para renderizar. Atualmente, componentes de carregamento *lazy* são a **única** finalidade que o `<React.Suspense>` presta suporte:
 
 ```js
 // Este componente é carregado dinamicamente

From 463557767c9210304bc1bd299cb7cc3683e09621 Mon Sep 17 00:00:00 2001
From: Cezar Augusto <boss@cezaraugusto.net>
Date: Sat, 9 Feb 2019 20:00:01 -0200
Subject: [PATCH 13/54] Update content/docs/reference-react.md

Co-Authored-By: renato-bohler <renato.bohler@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index c3fe66cc1..92e07dec7 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -353,7 +353,7 @@ function MyComponent() {
 
 Isto está documentado em nosso [guia para *code splitting*](/docs/code-splitting.html#reactlazy). Note que componentes `lazy` podem estar em níveis profundos dentro da árvore de `Suspense` -- ele não precisa envolver cada um deles. A melhor prática é colocar `<Suspense>` onde você quer ver um indicador de carregamento, mas utilizar `lazy()` onde você quiser realizar *code splitting*.
 
-Enquanto isto ainda não é suportado, no futuro nós planejamos permitir que `Suspense` lide com mais cenários como busca de dados. Você pode ler sobre isso em [nosso *roadmap*](/blog/2018/11/27/react-16-roadmap.html).
+Enquanto o React não presta suporte a isto, no futuro nós planejamos permitir que `Suspense` lide com mais cenários como busca de dados. Você pode ler sobre isso em [nosso *roadmap*](/blog/2018/11/27/react-16-roadmap.html).
 
 > Nota
 >

From 15681a1bc7c2961dfad869734f56cfcd87c60137 Mon Sep 17 00:00:00 2001
From: Cezar Augusto <boss@cezaraugusto.net>
Date: Sat, 9 Feb 2019 20:00:18 -0200
Subject: [PATCH 14/54] Update content/docs/reference-react.md

Co-Authored-By: renato-bohler <renato.bohler@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 92e07dec7..8b1505b85 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -357,4 +357,4 @@ Enquanto o React não presta suporte a isto, no futuro nós planejamos permitir
 
 > Nota
 >
-> `React.lazy()` e `<React.Suspense>` ainda não são suportados por `ReactDOMServer`. Esta é uma limitação conhecida que será resolvida futuramente.
+> `React.lazy()` e `<React.Suspense>` ainda não tem suporte através do `ReactDOMServer`. Esta é uma limitação conhecida que será resolvida futuramente.

From 40937cf00d0b84bb88500bfdff8439b6fa298eeb Mon Sep 17 00:00:00 2001
From: Cezar Augusto <boss@cezaraugusto.net>
Date: Sat, 9 Feb 2019 20:00:51 -0200
Subject: [PATCH 15/54] Update content/docs/reference-react.md

Co-Authored-By: renato-bohler <renato.bohler@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 8b1505b85..0f531aab1 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -112,7 +112,7 @@ Se o método `render()` do seu componente React renderiza o mesmo resultado dado
 >
 > O método `shouldComponentUpdate()` do `React.PureComponent` compara os objetos apenas superficialmente. Se eles contiverem estruturas de dados complexas, isto pode causar falso-negativos para diferenças mais profundas. Estenda `PureComponent` quando você espera possuir props e state simples, ou então use [`forceUpdate()`](/docs/react-component.html#forceupdate) quando você souber que ocorreram mudanças profundas na estrutura de dados.
 >
-> Além disso, o método `shouldComponentUpdate()` de `React.PureComponent` pula atualizações de prop para toda a subárvore do componente. Esteja certo de que todos seus componentes filho são também são "puros".
+> Além disso, o método `shouldComponentUpdate()` do `React.PureComponent` pula atualizações de prop para toda a subárvore do componente. Esteja certo de que todos seus componentes que descendem dele também são "puros".
 
 * * *
 

From 748bda03e0e55363b84a89628fde5d95f149d4e3 Mon Sep 17 00:00:00 2001
From: Cezar Augusto <boss@cezaraugusto.net>
Date: Sat, 9 Feb 2019 20:01:23 -0200
Subject: [PATCH 16/54] Update content/docs/reference-react.md

Co-Authored-By: renato-bohler <renato.bohler@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 0f531aab1..76a4341cd 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -124,7 +124,7 @@ const MyComponent = React.memo(function MyComponent(props) {
 });
 ```
 
-`React.memo` é um *[higher order component](/docs/higher-order-components.html)*. É similar a [`React.PureComponent`](#reactpurecomponent), mas para *function components* ao invés de classes.
+`O React.memo` é um *[higher order component](/docs/higher-order-components.html)*. É similar a [`React.PureComponent`](#reactpurecomponent), mas para *function components* ao invés de classes.
 
 Se seu *function component* renderiza o mesmo resultado dados os mesmos props, você pode envolver nele uma chamada para `React.memo` para um aumento no desempenho em alguns casos, através da memoização do resultado. Isto significa que o React vai pular a renderização do componente e reutilizar o último resultado renderizado.
 

From 32fd0790ccd3ddfb7ce06b1c2a0bdaa98f314179 Mon Sep 17 00:00:00 2001
From: Cezar Augusto <boss@cezaraugusto.net>
Date: Sat, 9 Feb 2019 20:01:48 -0200
Subject: [PATCH 17/54] Update content/docs/reference-react.md

Co-Authored-By: renato-bohler <renato.bohler@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 76a4341cd..7ada95f15 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -144,7 +144,7 @@ function areEqual(prevProps, nextProps) {
 export default React.memo(MyComponent, areEqual);
 ```
 
-Este método somente existe como uma **[otimização de performance](/docs/optimizing-performance.html).** Não conte com ele para "prevenir" uma renderização, pois isso pode levar a *bugs*.
+Este método existe somente como uma **[otimização de performance](/docs/optimizing-performance.html).** Não conte com ele para "prevenir" uma renderização, pois isso pode levar a *bugs*.
 
 > Nota
 >

From 940b54d92b35bafd1c86794be219d18cedd872af Mon Sep 17 00:00:00 2001
From: Cezar Augusto <boss@cezaraugusto.net>
Date: Sat, 9 Feb 2019 20:02:18 -0200
Subject: [PATCH 18/54] Update content/docs/reference-react.md

Co-Authored-By: renato-bohler <renato.bohler@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 7ada95f15..bb1861a0c 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -178,7 +178,7 @@ React.cloneElement(
 )
 ```
 
-Clona e retorna um novo elemento React usando `element` como ponto de partida. O elemento resultante terá os props do elemento original, com os novos props mesclados superficialmente. Novos elementos filho substituirão os existentes. `key` e `ref` do elemento original serão preservados.
+Clona e retorna um novo elemento React usando `element` como ponto de partida. O elemento resultante terá os props do elemento original, com os novos props mesclados superficialmente. Novos elementos filhos substituirão os existentes. `key` e `ref` do elemento original serão preservados.
 
 `React.cloneElement()` é quase equivalente a:
 

From ede5f5292148f24e36be89499c2f82ba609724d3 Mon Sep 17 00:00:00 2001
From: Cezar Augusto <boss@cezaraugusto.net>
Date: Sat, 9 Feb 2019 20:03:08 -0200
Subject: [PATCH 19/54] Update content/docs/reference-react.md

Co-Authored-By: renato-bohler <renato.bohler@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index bb1861a0c..a2d9c6458 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -162,7 +162,7 @@ React.createElement(
 )
 ```
 
-Cria e retorna um novo [elemento React](/docs/rendering-elements.html) do tipo dado. O argumento `type` pode ser uma *string* contendo o *tag name* (como, por exemplo, `'div'` ou `'span'`), um [componente React](/docs/components-and-props.html) (uma classe ou uma função), ou um [React *fragment*](#reactfragment).
+Cria e retorna um novo [elemento React](/docs/rendering-elements.html) do tipo determinado. O argumento `type` pode ser uma *string* contendo a *tag name* (como, por exemplo, `'div'` ou `'span'`), um [componente React](/docs/components-and-props.html) (uma classe ou uma função), ou um [React *fragment*](#reactfragment).
 
 Código escrito utilizando [JSX](/docs/introducing-jsx.html) será convertido para utilizar `React.createElement()`. Você tipicamente não invocará `React.createElement()` diretamente se você está usando JSX. Veja [React sem JSX](/docs/react-without-jsx.html) para aprender mais.
 

From 2f4a100501f5c088222036dfe025c5d687a58ab0 Mon Sep 17 00:00:00 2001
From: Cezar Augusto <boss@cezaraugusto.net>
Date: Sat, 9 Feb 2019 20:03:38 -0200
Subject: [PATCH 20/54] Update content/docs/reference-react.md

Co-Authored-By: renato-bohler <renato.bohler@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index a2d9c6458..53a00d412 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -164,7 +164,7 @@ React.createElement(
 
 Cria e retorna um novo [elemento React](/docs/rendering-elements.html) do tipo determinado. O argumento `type` pode ser uma *string* contendo a *tag name* (como, por exemplo, `'div'` ou `'span'`), um [componente React](/docs/components-and-props.html) (uma classe ou uma função), ou um [React *fragment*](#reactfragment).
 
-Código escrito utilizando [JSX](/docs/introducing-jsx.html) será convertido para utilizar `React.createElement()`. Você tipicamente não invocará `React.createElement()` diretamente se você está usando JSX. Veja [React sem JSX](/docs/react-without-jsx.html) para aprender mais.
+Código escrito utilizando [JSX](/docs/introducing-jsx.html) será convertido para utilizar `React.createElement()`. Você tipicamente não invocará `React.createElement()` diretamente se você estiver usando JSX. Veja [React sem JSX](/docs/react-without-jsx.html) para aprender mais.
 
 * * *
 

From 77de81a89f6682a6c157bba07050ab5c9c09888a Mon Sep 17 00:00:00 2001
From: Cezar Augusto <boss@cezaraugusto.net>
Date: Sat, 9 Feb 2019 20:04:29 -0200
Subject: [PATCH 21/54] Update content/docs/reference-react.md

Co-Authored-By: renato-bohler <renato.bohler@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 53a00d412..42347b2ae 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -201,7 +201,7 @@ Retorna uma função que produz elementos React de um dado tipo. Assim como em [
 
 Este *helper* é considerado legado, e nós encorajamos você a utilizar JSX ou `React.createElement()` diretamente como alternativa.
 
-Você tipicamente não invocará `React.createFactory()` diretamente se estiver utilizando JSX. Veja [React sem JSX](/docs/react-without-jsx.html) para aprender mais.
+Em geral você não invocará `React.createFactory()` diretamente se estiver utilizando JSX. Veja [React sem JSX](/docs/react-without-jsx.html) para aprender mais.
 
 * * *
 

From 5226d6448006f59a8cca0bbe4f21a9c627f97529 Mon Sep 17 00:00:00 2001
From: Cezar Augusto <boss@cezaraugusto.net>
Date: Sat, 9 Feb 2019 20:04:46 -0200
Subject: [PATCH 22/54] Update content/docs/reference-react.md

Co-Authored-By: renato-bohler <renato.bohler@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 42347b2ae..9d7421d6e 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -257,7 +257,7 @@ Verifica que `children` possui apenas um elemento filho (um elemento React) e o
 
 > Nota
 >
-> `React.Children.only()` não aceita o valor retornado de [`React.Children.map()`](#reactchildrenmap) pois este é um array ao invés de um elemento React.
+> O `React.Children.only()` não aceita o valor retornado de [`React.Children.map()`](#reactchildrenmap) pois este é um array ao invés de um elemento React.
 
 #### `React.Children.toArray` {#reactchildrentoarray}
 

From 0f1a20f351f4ad806fc859872cab83d95dcfcd57 Mon Sep 17 00:00:00 2001
From: Cezar Augusto <boss@cezaraugusto.net>
Date: Sat, 9 Feb 2019 20:05:02 -0200
Subject: [PATCH 23/54] Update content/docs/reference-react.md

Co-Authored-By: renato-bohler <renato.bohler@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 9d7421d6e..ccf33486c 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -293,7 +293,7 @@ Você também pode usar ele com a forma abreviada `<></>`. Para mais informaçõ
 
 ### `React.createRef` {#reactcreateref}
 
-`React.createRef` cria um [`ref`](/docs/refs-and-the-dom.html) que pode ser anexado a elementos React via atributo `ref`.
+`React.createRef` cria uma [`ref`](/docs/refs-and-the-dom.html) que pode ser anexada a elementos React através do atributo `ref`.
 
 `embed:16-3-release-blog-post/create-ref-example.js`
 

From e03015b696a5b2e522ca841534d0f7e4d4335136 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Renato=20B=C3=B6hler?= <renato.bohler@gmail.com>
Date: Sat, 9 Feb 2019 20:10:53 -0200
Subject: [PATCH 24/54] Update content/docs/reference-react.md

---
 content/docs/reference-react.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index ccf33486c..15468a2f6 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -49,7 +49,7 @@ O `React` provê várias *API*s para manipulação de elementos:
 
 ### Fragments {#fragments}
 
-`React` também provê um componente para renderizar múltiplos elementos sem um invólucro.
+O `React` também provê um componente para que você possa renderizar múltiplos elementos sem a necessidade de criar outro elemento que os envolva.
 
 - [`React.Fragment`](#reactfragment)
 
@@ -60,14 +60,14 @@ O `React` provê várias *API*s para manipulação de elementos:
 
 ### Suspense {#suspense}
 
-*Suspense* permite que componentes "esperem" por algo antes de renderizar. Atualmente, *Suspense* suporta somente somente um caso de uso: [carregando componentes dinamicamente com `React.lazy`](/docs/code-splitting.html#reactlazy). Futuramente, ele suportará outros casos de uso, como busca de dados.
+O *Suspense* permite que componentes "esperem" por algo antes de renderizar. Atualmente, o *Suspense* suporta somente uma finalidade: [carregar componentes dinamicamente com `React.lazy`](/docs/code-splitting.html#reactlazy). Futuramente, ele prestará suporte para outras finalidades, como busca de dados.
 
 - [`React.lazy`](#reactlazy)
 - [`React.Suspense`](#reactsuspense)
 
 ### Hooks {#hooks}
 
-*Hooks* são uma novidade no React 16.8. Eles permitem que você utilize estado e outras funcionalidades do React sem ter que escrever uma classe para isso. *Hooks* possuem uma [seção dedicada na documentação](/docs/hooks-intro.html) e uma referência da *API* separada:
+Os *Hooks* são uma novidade no React 16.8. Eles permitem que você utilize o estado (*state*) e outras funcionalidades do React sem ter que escrever uma classe para isso. Os *Hooks* possuem uma [seção dedicada na documentação](/docs/hooks-intro.html) e uma referência da *API* separada:
 
 - [*Hooks* Básicos](/docs/hooks-reference.html#basic-hooks)
   - [`useState`](/docs/hooks-reference.html#usestate)
@@ -98,7 +98,7 @@ class Greeting extends React.Component {
 }
 ```
 
-Veja a [referência da *API* para React.Component](/docs/react-component.html) para uma lista de métodos e propriedades relacionadas à classe base `React.Component`.
+Consulte a [referência da *API* para React.Component](/docs/react-component.html) para ver uma lista de métodos e propriedades relacionadas à classe base `React.Component`.
 
 * * *
 
@@ -137,7 +137,7 @@ function MyComponent(props) {
 function areEqual(prevProps, nextProps) {
   /*
   retorne true se passar nextProps renderizaria o mesmo
-  resultado se passasse prevProps,
+  resultado se passasse prevProps.
   do contrário, retorne false
   */
 }
@@ -197,7 +197,7 @@ Esta *API* foi introduzida como uma reposição ao `React.addons.cloneWithProps(
 ```javascript
 React.createFactory(type)
 ```
-Retorna uma função que produz elementos React de um dado tipo. Assim como em [`React.createElement()`](#createElement), o argumento `type` pode ser uma *string* contendo o *tag name* (como, por exemplo, `'div'` ou `'span'`), um [componente React](/docs/components-and-props.html) (uma classe ou uma função), ou um [React *fragment*](#reactfragment).
+Retorna uma função que produz elementos React do tipo determinado. Assim como em [`React.createElement()`](#createElement), o argumento `type` pode ser uma *string* contendo o *tag name* (como, por exemplo, `'div'` ou `'span'`), um [componente React](/docs/components-and-props.html) (uma classe ou uma função), ou um [React *fragment*](#reactfragment).
 
 Este *helper* é considerado legado, e nós encorajamos você a utilizar JSX ou `React.createElement()` diretamente como alternativa.
 

From 2c60f1895c9095a94f1576d64e7408b0f34d0e07 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Renato=20B=C3=B6hler?= <renato.bohler@gmail.com>
Date: Sat, 9 Feb 2019 20:37:13 -0200
Subject: [PATCH 25/54] Update content/docs/reference-react.md

---
 content/docs/reference-react.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 15468a2f6..7105a8d57 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -136,9 +136,9 @@ function MyComponent(props) {
 }
 function areEqual(prevProps, nextProps) {
   /*
-  retorne true se passar nextProps renderizaria o mesmo
-  resultado se passasse prevProps.
-  do contrário, retorne false
+  se prevProps e nextProps renderizam o mesmo resultado,
+  retorne true.
+  caso contrário, retorne false.
   */
 }
 export default React.memo(MyComponent, areEqual);

From 7d0c549696f0d2fb7df6e507367f7d0d3e0a6423 Mon Sep 17 00:00:00 2001
From: Renan Silveira <renan.silveira@agrotis.com>
Date: Wed, 20 Feb 2019 13:15:33 -0300
Subject: [PATCH 26/54] updating reference react-component

---
 content/docs/reference-react-component.md | 64 ++++++++++++-----------
 1 file changed, 34 insertions(+), 30 deletions(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index ecb4d087c..313547240 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -15,50 +15,55 @@ redirect_from:
   - "tips/use-react-with-other-libraries.html"
 ---
 
-This page contains a detailed API reference for the React component class definition. It assumes you're familiar with fundamental React concepts, such as [Components and Props](/docs/components-and-props.html), as well as [State and Lifecycle](/docs/state-and-lifecycle.html). If you're not, read them first.
 
-## Overview {#overview}
+Esta página contem uma referência detalhada da API para a definição de classes de componentes React. Nós assumimos que você possui familiaridade com conceitos fundamentais do React, como [Componentes e Props](/docs/components-and-props.html), bem como [State e Lifecycle](/docs/state-and-lifecycle.html). Se isto não é familiar para você, leia essas páginas primeiro.
 
-React lets you define components as classes or functions. Components defined as classes currently provide more features which are described in detail on this page. To define a React component class, you need to extend `React.Component`:
+
+## Visão Geral {#overview}
+
+React permite definirmos componentes como classes ou como funções. Componentes definidos como classes possuem mais funcionalidades que serão detalhadas nesta página. Para definir uma classe componente, ela precisa estender a classe `React.Component`:
 
 ```js
 class Welcome extends React.Component {
   render() {
-    return <h1>Hello, {this.props.name}</h1>;
+    return <h1>Olá, {this.props.name}</h1>;
   }
 }
 ```
 
-The only method you *must* define in a `React.Component` subclass is called [`render()`](#render). All the other methods described on this page are optional.
+O único método que você *deve* definir em uma subclasse de `React.Component` é chamado [`render()`](#render). Todos os outros métodos descritos nesta página são opcionais.
 
-**We strongly recommend against creating your own base component classes.** In React components, [code reuse is primarily achieved through composition rather than inheritance](/docs/composition-vs-inheritance.html).
+**Nós somos fortemente contra a criação de seus próprios componentes base.** Em componentes React, [O reuso do código é obtido primariamente através de composição ao invés de herança]
+(/docs/composition-vs-inheritance.html).
 
->Note:
+>Nota:
 >
->React doesn't force you to use the ES6 class syntax. If you prefer to avoid it, you may use the `create-react-class` module or a similar custom abstraction instead. Take a look at [Using React without ES6](/docs/react-without-es6.html) to learn more.
+>React não te obriga a utilizar a sintaxe ES6 para classes. Se preferir não usá-la, você pode usar o módulo `create-react-class` ou alguma outra abstração similar. Dê uma olhada em 
+[Usando React sem ES6](/docs/react-without-es6.html) para mais sobre este assunto.
 
-### The Component Lifecycle {#the-component-lifecycle}
+### O Ciclo de vida de um Componente {#ciclo-de-vida-de-componentes}
 
-Each component has several "lifecycle methods" that you can override to run code at particular times in the process. **You can use [this lifecycle diagram](http://projects.wojtekmaj.pl/react-lifecycle-methods-diagram/) as a cheat sheet.** In the list below, commonly used lifecycle methods are marked as **bold**. The rest of them exist for relatively rare use cases.
+Cada componente possui muitos "métodos do ciclo de vida" que você pode sobrescrever para executar determinado código em momentos particulares do processo. **Você pode usar [este diagrama do ciclo de vida](http://projects.wojtekmaj.pl/react-lifecycle-methods-diagram/) para consulta.** Na lista abaixo, os métodos do ciclo de vida mais usados estão marcados em **negrito**. O resto deles, existe para o uso em casos relativamente raros.
 
-#### Mounting {#mounting}
+#### Montando {#montando}
+
+Estes métodos são chamados na seguinte ordem quando uma instância de um componente está sendo criada e inserida no DOM:
 
-These methods are called in the following order when an instance of a component is being created and inserted into the DOM:
 
 - [**`constructor()`**](#constructor)
 - [`static getDerivedStateFromProps()`](#static-getderivedstatefromprops)
 - [**`render()`**](#render)
 - [**`componentDidMount()`**](#componentdidmount)
 
->Note:
+>Nota:
 >
->These methods are considered legacy and you should [avoid them](/blog/2018/03/27/update-on-async-rendering.html) in new code:
+>Estes métodos são considerados legado e você deve [evitá-los]/blog/2018/03/27/update-on-async-rendering.html) em código novo:
 >
 >- [`UNSAFE_componentWillMount()`](#unsafe_componentwillmount)
 
-#### Updating {#updating}
+#### Atualizando {#atualizando}
 
-An update can be caused by changes to props or state. These methods are called in the following order when a component is being re-rendered:
+Uma atualização pode ser causada por alterações em props ou no state. Estes métodos são chamados na seguinte ordem quando um componente esta sendo re-renderizado:
 
 - [`static getDerivedStateFromProps()`](#static-getderivedstatefromprops)
 - [`shouldComponentUpdate()`](#shouldcomponentupdate)
@@ -66,50 +71,49 @@ An update can be caused by changes to props or state. These methods are called i
 - [`getSnapshotBeforeUpdate()`](#getsnapshotbeforeupdate)
 - [**`componentDidUpdate()`**](#componentdidupdate)
 
->Note:
+>Nota:
 >
->These methods are considered legacy and you should [avoid them](/blog/2018/03/27/update-on-async-rendering.html) in new code:
+>Estes métodos são considerados legado e você deve [evitá-los]/blog/2018/03/27/update-on-async-rendering.html) em código novo:
 >
 >- [`UNSAFE_componentWillUpdate()`](#unsafe_componentwillupdate)
 >- [`UNSAFE_componentWillReceiveProps()`](#unsafe_componentwillreceiveprops)
 
-#### Unmounting {#unmounting}
+#### Desmontando {#desmontando}
 
-This method is called when a component is being removed from the DOM:
+Estes métodos são chamados quando um componente está sendo removido do DOM:
 
 - [**`componentWillUnmount()`**](#componentwillunmount)
 
-#### Error Handling {#error-handling}
+#### Tratando erros {#tratando-erros}
 
-These methods are called when there is an error during rendering, in a lifecycle method, or in the constructor of any child component.
+Estes métodos são chamados quando existir um erro durante a renderização, em um método do ciclo de vida, ou no construtor de qualquer componente-filho.
 
 - [`static getDerivedStateFromError()`](#static-getderivedstatefromerror)
 - [`componentDidCatch()`](#componentdidcatch)
 
-### Other APIs {#other-apis}
+### Outras APIs {#outras-apis}
 
-Each component also provides some other APIs:
+Cada componente também fornece outras APIs:
 
   - [`setState()`](#setstate)
   - [`forceUpdate()`](#forceupdate)
 
-### Class Properties {#class-properties}
+### Propriedades de Classes {#propriedades-de-classes}
 
   - [`defaultProps`](#defaultprops)
   - [`displayName`](#displayname)
 
-### Instance Properties {#instance-properties}
+### Propriedades da instância {#propriedades-da-instância}
 
   - [`props`](#props)
   - [`state`](#state)
 
 * * *
 
-## Reference {#reference}
-
-### Commonly Used Lifecycle Methods {#commonly-used-lifecycle-methods}
+## Referencia {#referencia}
 
-The methods in this section cover the vast majority of use cases you'll encounter creating React components. **For a visual reference, check out [this lifecycle diagram](http://projects.wojtekmaj.pl/react-lifecycle-methods-diagram/).**
+### Métodos mais usados do Ciclo de Vida {#métodos-mais-usados-do-ciclo-de-vida}
+Os métodos desta seção cobrem a grande maioria dos casos de uso que você encontrará criando componentes React. **Para uma referência visual, veja : [este diagrama do ciclo de vida](http://projects.wojtekmaj.pl/react-lifecycle-methods-diagram/).**
 
 ### `render()` {#render}
 

From 40180f558f95f6173e6eed435112a67ffd0b89df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Renato=20B=C3=B6hler?= <renato.bohler@agrotis.com>
Date: Wed, 20 Feb 2019 17:53:34 -0300
Subject: [PATCH 27/54] translates error boundaries section in
 reference-react-component

---
 content/docs/reference-react-component.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index 313547240..b5b7cf27b 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -319,17 +319,17 @@ In the above examples, it is important to read the `scrollHeight` property in `g
 
 ### Error boundaries {#error-boundaries}
 
-[Error boundaries](/docs/error-boundaries.html) are React components that catch JavaScript errors anywhere in their child component tree, log those errors, and display a fallback UI instead of the component tree that crashed. Error boundaries catch errors during rendering, in lifecycle methods, and in constructors of the whole tree below them.
+Os *[error boundaries](/docs/error-boundaries.html)* são componentes React que realizam o *catch* de erros de JavaScript em qualquer parte da sua árvore de componentes filhos, realiza o *log* destes erros e exibe uma UI de *fallback* ao invés da árvore de componentes que quebrou. Os *Error boundary* realizam o *catch* de erros durante a renderização, nos métodos do lifecycle e em construtores de toda a sua árvore descendente.
 
-A class component becomes an error boundary if it defines either (or both) of the lifecycle methods `static getDerivedStateFromError()` or `componentDidCatch()`. Updating state from these lifecycles lets you capture an unhandled JavaScript error in the below tree and display a fallback UI.
+Um *class component* se torna um *error boundary* caso ele defina um dos (ou ambos) métodos do lifecycle `static getDerivedStateFromError()` ou `componentDidCatch()`. Atualizar o *state* a partir destes lifecycles permite que você capture um erro JavaScript não tratado na árvore de descendentes e exiba uma UI de *fallback*.
 
-Only use error boundaries for recovering from unexpected exceptions; **don't try to use them for control flow.**
+Somente utilize *error boundaries* para recuperação de exceções inesperadas; **não tente utilizá-lo para controlar o fluxo.**
 
-For more details, see [*Error Handling in React 16*](/blog/2017/07/26/error-handling-in-react-16.html).
+Para mais detalhes, veja *[Tratamento de Erros no React 16](/blog/2017/07/26/error-handling-in-react-16.html)*.
 
-> Note
-> 
-> Error boundaries only catch errors in the components **below** them in the tree. An error boundary can’t catch an error within itself.
+> Nota
+>
+> Os *error boundaries* somente realizam *catch* nos componentes **abaixo** dele na árvore. Um *error boundary* não pode realizar o *catch* de um erro dentro de si próprio.
 
 ### `static getDerivedStateFromError()` {#static-getderivedstatefromerror}
 ```javascript

From 7e1a8f3a494e4fe2875df0adf4743968c97605f6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Renato=20B=C3=B6hler?= <renato.bohler@agrotis.com>
Date: Wed, 20 Feb 2019 18:03:59 -0300
Subject: [PATCH 28/54] translates getDerivedStateFromError section in
 reference-react-component

---
 content/docs/reference-react-component.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index b5b7cf27b..be2d8fba6 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -336,8 +336,8 @@ Para mais detalhes, veja *[Tratamento de Erros no React 16](/blog/2017/07/26/err
 static getDerivedStateFromError(error)
 ```
 
-This lifecycle is invoked after an error has been thrown by a descendant component.
-It receives the error that was thrown as a parameter and should return a value to update state.
+Este *lifecycle* é invocado após um erro ser lançado por um componente descendente.
+Ele recebe o erro que foi lançado como parâmetro e deve retornar um valor para atualizar o *state*.
 
 ```js{7-10,13-16}
 class ErrorBoundary extends React.Component {
@@ -347,13 +347,13 @@ class ErrorBoundary extends React.Component {
   }
 
   static getDerivedStateFromError(error) {
-    // Update state so the next render will show the fallback UI.
+    // Atualize o state para que a próxima renderização exiba a UI de fallback.
     return { hasError: true };
   }
 
   render() {
     if (this.state.hasError) {
-      // You can render any custom fallback UI
+      // Você pode renderizar qualquer UI como fallback
       return <h1>Something went wrong.</h1>;
     }
 
@@ -362,10 +362,10 @@ class ErrorBoundary extends React.Component {
 }
 ```
 
-> Note
+> Nota
 >
-> `getDerivedStateFromError()` is called during the "render" phase, so side-effects are not permitted.
-For those use cases, use `componentDidCatch()` instead.
+> `getDerivedStateFromError()` é chamado durante a fase de renderização, portanto efeitos colaterais (*side-effects*) não são permitidos.
+> Para estes casos de uso, utilize `componentDidCatch()` como alternativa.
 
 * * *
 

From 0f9b2e2b6acb86fb657f4250a1f396c22a39f420 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Renato=20B=C3=B6hler?= <renato.bohler@agrotis.com>
Date: Wed, 20 Feb 2019 18:04:19 -0300
Subject: [PATCH 29/54] translates componentDidCatch section in
 reference-react-component

---
 content/docs/reference-react-component.md | 27 +++++++++++------------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index be2d8fba6..97a9df5f4 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -375,15 +375,14 @@ class ErrorBoundary extends React.Component {
 componentDidCatch(error, info)
 ```
 
-This lifecycle is invoked after an error has been thrown by a descendant component.
-It receives two parameters:
+Este lifecycle é invocado após um erro ter sido lançado por um componente descendente.
+Ele recebe dois parâmetros:
 
-1. `error` - The error that was thrown.
-2. `info` - An object with a `componentStack` key containing [information about which component threw the error](/docs/error-boundaries.html#component-stack-traces).
+1. `error` - O erro que foi lançado.
+2. `info` - Um objeto com uma chave `componentStack` contendo [informações sobre qual componente lançou o erro](/docs/error-boundaries.html#component-stack-traces).
 
-
-`componentDidCatch()` is called during the "commit" phase, so side-effects are permitted.
-It should be used for things like logging errors:
+`componentDidCatch()` é chamado durante a fase de "commit", portanto efeitos colaterais (*side-effects*) não são permitidos.
+Ele deveria ser usado para, por exemplo, realizar o *log* de erros:
 
 ```js{12-19}
 class ErrorBoundary extends React.Component {
@@ -393,12 +392,12 @@ class ErrorBoundary extends React.Component {
   }
 
   static getDerivedStateFromError(error) {
-    // Update state so the next render will show the fallback UI.
+    // Atualize o state para que a próxima renderização exiba a UI de fallback.
     return { hasError: true };
   }
 
   componentDidCatch(error, info) {
-    // Example "componentStack":
+    // Examplo de "componentStack":
     //   in ComponentThatThrows (created by App)
     //   in ErrorBoundary (created by App)
     //   in div (created by App)
@@ -408,7 +407,7 @@ class ErrorBoundary extends React.Component {
 
   render() {
     if (this.state.hasError) {
-      // You can render any custom fallback UI
+      // Você pode renderizar qualquer UI como fallback
       return <h1>Something went wrong.</h1>;
     }
 
@@ -417,10 +416,10 @@ class ErrorBoundary extends React.Component {
 }
 ```
 
-> Note
-> 
-> In the event of an error, you can render a fallback UI with `componentDidCatch()` by calling `setState`, but this will be deprecated in a future release.
-> Use `static getDerivedStateFromError()` to handle fallback rendering instead.
+> Nota
+>
+> No evento de um erro, você pode renderizar uma UI de *fallback* com `componentDidCatch()` chamando `setState`, mas isto será depreciado numa *release* futura.
+> Use `static getDerivedStateFromError()` para manipular a renderização de *fallback* como alternativa.
 
 * * *
 

From 33690f4e8c9b77e402e70d3ccaa9422a22658b49 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Renato=20B=C3=B6hler?= <renato.bohler@agrotis.com>
Date: Wed, 20 Feb 2019 18:06:05 -0300
Subject: [PATCH 30/54] translates legacy lifecycle methods section in
 reference-react-component

---
 content/docs/reference-react-component.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index 97a9df5f4..cd179a9a9 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -423,9 +423,9 @@ class ErrorBoundary extends React.Component {
 
 * * *
 
-### Legacy Lifecycle Methods {#legacy-lifecycle-methods}
+### Métodos legado do lifecycle {#legacy-lifecycle-methods}
 
-The lifecycle methods below are marked as "legacy". They still work, but we don't recommend using them in the new code. You can learn more about migrating away from legacy lifecycle methods in [this blog post](/blog/2018/03/27/update-on-async-rendering.html).
+Os métodos do lifecycle abaixo estão marcados como "legado". Eles ainda funcionam, mas não recomendamos utilizar eles em código novo. Você pode aprender mais sobre a migração de métodos legado do lifecycle [neste post no blog](/blog/2018/03/27/update-on-async-rendering.html).
 
 ### `UNSAFE_componentWillMount()` {#unsafe_componentwillmount}
 

From cc531572b3d3b3bc3bcfcf53b54b6a38722a8737 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Renato=20B=C3=B6hler?= <renato.bohler@agrotis.com>
Date: Wed, 20 Feb 2019 18:09:25 -0300
Subject: [PATCH 31/54] translates componentWillMount section in
 reference-react-component

---
 content/docs/reference-react-component.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index cd179a9a9..ea52ca397 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -433,15 +433,15 @@ Os métodos do lifecycle abaixo estão marcados como "legado". Eles ainda funcio
 UNSAFE_componentWillMount()
 ```
 
-> Note
+> Nota
 >
-> This lifecycle was previously named `componentWillMount`. That name will continue to work until version 17. Use the [`rename-unsafe-lifecycles` codemod](https://github.com/reactjs/react-codemod#rename-unsafe-lifecycles) to automatically update your components.
+> Este lifecycle era nomeado `componentWillMount`. Este nome continuará a funcionar até a versão 17. Utilize o [codemod `rename-unsafe-lifecycles`](https://github.com/reactjs/react-codemod#rename-unsafe-lifecycles) para atualizar automaticamente seus componentes.
 
-`UNSAFE_componentWillMount()` is invoked just before mounting occurs. It is called before `render()`, therefore calling `setState()` synchronously in this method will not trigger an extra rendering. Generally, we recommend using the `constructor()` instead for initializing state.
+`UNSAFE_componentWillMount()` é invocado antes que a montagem ocorra. Ele é chamado antes de `render()`, portanto chamar `setState()` sincronamente neste método não irá acarretar numa renderização extra. Geralmente, nós recomendamos o `constructor()` como alternativa para inicializar o *state*.
 
-Avoid introducing any side-effects or subscriptions in this method. For those use cases, use `componentDidMount()` instead.
+Evite introduzir quaisquer efeitos colaterais (*side-effects*) ou *subscriptions* neste método. Para estes casos de uso, utilize `componentDidMount()`.
 
-This is the only lifecycle method called on server rendering.
+Este é o único método do lifecycle chamado em *server rendering*.
 
 * * *
 

From 33abe022106bf3be4c38035b976e1a2b31a7b7f7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Renato=20B=C3=B6hler?= <renato.bohler@agrotis.com>
Date: Wed, 20 Feb 2019 18:18:49 -0300
Subject: [PATCH 32/54] translates componentWillReceiveProps section in
 reference-react-component

---
 content/docs/reference-react-component.md | 25 +++++++++++------------
 1 file changed, 12 insertions(+), 13 deletions(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index ea52ca397..6bead4854 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -437,7 +437,7 @@ UNSAFE_componentWillMount()
 >
 > Este lifecycle era nomeado `componentWillMount`. Este nome continuará a funcionar até a versão 17. Utilize o [codemod `rename-unsafe-lifecycles`](https://github.com/reactjs/react-codemod#rename-unsafe-lifecycles) para atualizar automaticamente seus componentes.
 
-`UNSAFE_componentWillMount()` é invocado antes que a montagem ocorra. Ele é chamado antes de `render()`, portanto chamar `setState()` sincronamente neste método não irá acarretar numa renderização extra. Geralmente, nós recomendamos o `constructor()` como alternativa para inicializar o *state*.
+`UNSAFE_componentWillMount()` é invocado antes que o *mounting* ocorra. Ele é chamado antes de `render()`, portanto chamar `setState()` sincronamente neste método não irá acarretar numa renderização extra. Geralmente, nós recomendamos o `constructor()` como alternativa para inicializar o *state*.
 
 Evite introduzir quaisquer efeitos colaterais (*side-effects*) ou *subscriptions* neste método. Para estes casos de uso, utilize `componentDidMount()`.
 
@@ -451,25 +451,24 @@ Este é o único método do lifecycle chamado em *server rendering*.
 UNSAFE_componentWillReceiveProps(nextProps)
 ```
 
-> Note
+> Nota
 >
-> This lifecycle was previously named `componentWillReceiveProps`. That name will continue to work until version 17. Use the [`rename-unsafe-lifecycles` codemod](https://github.com/reactjs/react-codemod#rename-unsafe-lifecycles) to automatically update your components.
+> Este lifecycle era nomeado `componentWillReceiveProps`. Este nome continuará a funcionar até a versão 17. Utilize o [codemod `rename-unsafe-lifecycles`](https://github.com/reactjs/react-codemod#rename-unsafe-lifecycles) para atualizar automaticamente seus componentes.
 
-> Note:
->
-> Using this lifecycle method often leads to bugs and inconsistencies
+> Nota
 >
-> * If you need to **perform a side effect** (for example, data fetching or an animation) in response to a change in props, use [`componentDidUpdate`](#componentdidupdate) lifecycle instead.
-> * If you used `componentWillReceiveProps` for **re-computing some data only when a prop changes**, [use a memoization helper instead](/blog/2018/06/07/you-probably-dont-need-derived-state.html#what-about-memoization).
-> * If you used `componentWillReceiveProps` to **"reset" some state when a prop changes**, consider either making a component [fully controlled](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-controlled-component) or [fully uncontrolled with a `key`](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-uncontrolled-component-with-a-key) instead.
+> Utilizar este método do lifecycle frequentemente acarreta em *bugs* e inconsistências.
 >
-> For other use cases, [follow the recommendations in this blog post about derived state](/blog/2018/06/07/you-probably-dont-need-derived-state.html).
+> * Se você precisar causar um *side-effect* (por exemplo, buscar dados um realizar uma animação) em resposta a uma mudança nas *props*, utilize o método do lifecycle [`componentDidUpdate`](#componentdidupdate) como alternativa.
+> * Se você usa `componentWillReceiveProps` para **recomputar algum dado somente quando uma *prop* muda**, [utilize um *memoization helper*](/blog/2018/06/07/you-probably-dont-need-derived-state.html#what-about-memoization).
+> * Se você usa `componentWillReceiveProps` para **"resetar" algum *state* quando uma *prop* muda**, considere ou criar um componente [completamente controlado](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-controlled-component) ou [completamente não controlado com uma `key`](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-uncontrolled-component-with-a-key) como alternativa.
+> Para outros casos de uso, [siga as recomendações neste *post* do *blog* sobre *derived state*](/blog/2018/06/07/you-probably-dont-need-derived-state.html).
 
-`UNSAFE_componentWillReceiveProps()` is invoked before a mounted component receives new props. If you need to update the state in response to prop changes (for example, to reset it), you may compare `this.props` and `nextProps` and perform state transitions using `this.setState()` in this method.
+`UNSAFE_componentWillReceiveProps()` é invocado antes que um componente montado receba novas *props*. Se você precisa atualizar o estado em resposta a mudanças na *prop* (por exemplo, para resetá-lo), você pode comparar `this.props` e `nextProps` e realizar transições de *state* utilizando `this.setState()` neste método.
 
-Note that if a parent component causes your component to re-render, this method will be called even if props have not changed. Make sure to compare the current and next values if you only want to handle changes.
+Note que se um componente pai causar a rerenderização do seu componente, este método será chamado mesmo se as *props* não foram alteradas. Certifique-se de comparar o valor atual e o próximo se você deseja somente manipular mudanças.
 
-React doesn't call `UNSAFE_componentWillReceiveProps()` with initial props during [mounting](#mounting). It only calls this method if some of component's props may update. Calling `this.setState()` generally doesn't trigger `UNSAFE_componentWillReceiveProps()`.
+O React não chama `UNSAFE_componentWillReceiveProps()` com *props* iniciais durante o *[mounting](#mounting)*. Ele só chama este método se alguma das *props* do componente puderem atualizar. Chamar `this.setState()` geralmente não desencadeia uma outra chamada `UNSAFE_componentWillReceiveProps()`.
 
 * * *
 

From d46ccba83c24203a65be6998551ed2c8e5bd7d63 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Renato=20B=C3=B6hler?= <renato.bohler@agrotis.com>
Date: Wed, 20 Feb 2019 18:23:22 -0300
Subject: [PATCH 33/54] translates componentWillUpdate section in
 reference-react-component

---
 content/docs/reference-react-component.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index 6bead4854..eaffa1205 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -478,19 +478,19 @@ O React não chama `UNSAFE_componentWillReceiveProps()` com *props* iniciais dur
 UNSAFE_componentWillUpdate(nextProps, nextState)
 ```
 
-> Note
+> Nota
 >
-> This lifecycle was previously named `componentWillUpdate`. That name will continue to work until version 17. Use the [`rename-unsafe-lifecycles` codemod](https://github.com/reactjs/react-codemod#rename-unsafe-lifecycles) to automatically update your components.
+> Este lifecycle era nomeado `componentWillUpdate`. Este nome continuará a funcionar até a versão 17. Utilize o [codemod `rename-unsafe-lifecycles`](https://github.com/reactjs/react-codemod#rename-unsafe-lifecycles) para atualizar automaticamente seus componentes.
 
-`UNSAFE_componentWillUpdate()` is invoked just before rendering when new props or state are being received. Use this as an opportunity to perform preparation before an update occurs. This method is not called for the initial render.
+`UNSAFE_componentWillUpdate()` é invocado antes da renderização quando novas *props* ou *state* estão sendo recebidos. Utilize este método como uma oportunidade para realizar preparações antes que uma atualização ocorra. Este método não é chamado para a renderização inicial.
 
-Note that you cannot call `this.setState()` here; nor should you do anything else (e.g. dispatch a Redux action) that would trigger an update to a React component before `UNSAFE_componentWillUpdate()` returns.
+Note que você não pode chamar `this.setState()` aqui; e nem deveria fazer nada além (por exemplo, realizar o *dispatch* de uma *action* do *Redux*) que desencadearia uma atualização em um componente React antes que `UNSAFE_componentWillUpdate()` retorne.
 
-Typically, this method can be replaced by `componentDidUpdate()`. If you were reading from the DOM in this method (e.g. to save a scroll position), you can move that logic to `getSnapshotBeforeUpdate()`.
+Tipicamente, este método pode ser substituído por `componentDidUpdate()`. Se você estiver lendo do *DOM* neste método (por exemplo, para salvar a posição de rolagem), você pode mover esta lógica para `getSnapshotBeforeUpdate()`.
 
-> Note
+> Nota
 >
-> `UNSAFE_componentWillUpdate()` will not be invoked if [`shouldComponentUpdate()`](#shouldcomponentupdate) returns false.
+> `UNSAFE_componentWillUpdate()` não será invocado se [`shouldComponentUpdate()`](#shouldcomponentupdate) retornar *false*.
 
 * * *
 

From a36f6d67eca0aa3d016c345ed96b4c4a4c790b87 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Renato=20B=C3=B6hler?= <renato.bohler@agrotis.com>
Date: Thu, 21 Feb 2019 08:04:44 -0300
Subject: [PATCH 34/54] translates Other APIs section in
 reference-react-component

---
 content/docs/reference-react-component.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index eaffa1205..5ae4cfa13 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -494,11 +494,11 @@ Tipicamente, este método pode ser substituído por `componentDidUpdate()`. Se v
 
 * * *
 
-## Other APIs {#other-apis-1}
+## Outras APIs {#other-apis-1}
 
-Unlike the lifecycle methods above (which React calls for you), the methods below are the methods *you* can call from your components.
+Diferentemente dos métodos do *lifecycle* acima (que o React chama por você), os métodos abaixo são métodos que *você* pode chamar a partir de seus componentes.
 
-There are just two of them: `setState()` and `forceUpdate()`.
+Existem apenas dois deles: `setState()` e `forceUpdate()`.
 
 ### `setState()` {#setstate}
 

From 3a9d486b76708a521d9adc8e410ea9e4bb2a03cb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Renato=20B=C3=B6hler?= <renato.bohler@agrotis.com>
Date: Thu, 21 Feb 2019 08:27:14 -0300
Subject: [PATCH 35/54] translates setState section in
 reference-react-component

---
 content/docs/reference-react-component.md | 32 +++++++++++------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index 5ae4cfa13..ff446f921 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -506,21 +506,21 @@ Existem apenas dois deles: `setState()` e `forceUpdate()`.
 setState(updater[, callback])
 ```
 
-`setState()` enqueues changes to the component state and tells React that this component and its children need to be re-rendered with the updated state. This is the primary method you use to update the user interface in response to event handlers and server responses.
+`setState()` enfileira mudanças ao *state* do componente e diz ao React que este componente e seus componentes filho precisam ser rerenderizados com a atualização do *state*. Este é o principal método que você utiliza para atualizar a UI em resposta a *event handlers* e à resposta de servidores.
 
-Think of `setState()` as a *request* rather than an immediate command to update the component. For better perceived performance, React may delay it, and then update several components in a single pass. React does not guarantee that the state changes are applied immediately.
+Pense em `setState()` como uma *requisição* ao invés de um comando imediato para atualizar o componente. Para uma melhoria na performance, o React pode atrasar a atualização, e então atualizar diversos componentes numa só leva. O React não garante que as mudanças no *state* são aplicadas imediatamente.
 
-`setState()` does not always immediately update the component. It may batch or defer the update until later. This makes reading `this.state` right after calling `setState()` a potential pitfall. Instead, use `componentDidUpdate` or a `setState` callback (`setState(updater, callback)`), either of which are guaranteed to fire after the update has been applied. If you need to set the state based on the previous state, read about the `updater` argument below.
+`setState()` nem sempre atualiza o componente imediatamente. Ele pode adiar a atualização para mais tarde. Isto torna a leitura de `this.state` logo após chamar `setState()` uma potencial cilada. Como alternativa, utilize `componentDidUpdate` ou o *callback* de `setState` (`setState(updater, callback)`), ambos possuem a garantia de dispararem após a aplicação da atualização. Se você precisa definir o *state* baseado no *state* anterior, leia sobre o argumento `updater` abaixo.
 
-`setState()` will always lead to a re-render unless `shouldComponentUpdate()` returns `false`. If mutable objects are being used and conditional rendering logic cannot be implemented in `shouldComponentUpdate()`, calling `setState()` only when the new state differs from the previous state will avoid unnecessary re-renders.
+`setState()` vai sempre conduzir a uma rerenderização a menos que `shouldComponentUpdate()` retorne `false`. Se objetos mutáveis estão sendo utilizados e lógica de renderização condicional não puder ser implementada em `shouldComponentUpdate()`, chamar `setState()` somente quando o novo *state* diferir do *state* anterior irá evitar rerenderizações desnecessárias.
 
-The first argument is an `updater` function with the signature:
+O primeiro argumento é uma função `updater` com a assinatura:
 
 ```javascript
 (state, props) => stateChange
 ```
 
-`state` is a reference to the component state at the time the change is being applied. It should not be directly mutated. Instead, changes should be represented by building a new object based on the input from `state` and `props`. For instance, suppose we wanted to increment a value in state by `props.step`:
+`state` é a referência ao *state* do componente no momento que a mudança está sendo aplicada. Ele não deve ser mutado diretamente. As mudanças devem ser representadas construindo um novo objeto baseado no *input* de *state* e *props*. Por exemplo, suponha que queiramos incrementar um valor no *state* em `props.step`:
 
 ```javascript
 this.setState((state, props) => {
@@ -528,23 +528,23 @@ this.setState((state, props) => {
 });
 ```
 
-Both `state` and `props` received by the updater function are guaranteed to be up-to-date. The output of the updater is shallowly merged with `state`.
+Tanto `state` quanto `props` que foram recebidas pela função `updater` tem a garantia de estarem atualizados. A saída do *updater* é superficialmente mesclada com o *state*.
 
-The second parameter to `setState()` is an optional callback function that will be executed once `setState` is completed and the component is re-rendered. Generally we recommend using `componentDidUpdate()` for such logic instead.
+O segundo parâmetro de `setState()` é uma função de *callback* opcional que será executada assim que `setState` for completada e o componente rerenderizado. Geralmente, recomendamos utilizar `componentDidUpdate()` para implementar esta lógica.
 
-You may optionally pass an object as the first argument to `setState()` instead of a function:
+Você também pode passar um objeto como primeiro argumento de `setState()` ao invés de uma função:
 
 ```javascript
 setState(stateChange[, callback])
 ```
 
-This performs a shallow merge of `stateChange` into the new state, e.g., to adjust a shopping cart item quantity:
+Isto realiza uma mescla superficial de `stateChange` dentro no novo *state*. Por exemplo: para ajustar a quantidade de items no carrinho de compras:
 
 ```javascript
 this.setState({quantity: 2})
 ```
 
-This form of `setState()` is also asynchronous, and multiple calls during the same cycle may be batched together. For example, if you attempt to increment an item quantity more than once in the same cycle, that will result in the equivalent of:
+Esta forma de `setState()` também é assíncrona, e múltiplas chamadas durante o mesmo ciclo podem ser agrupadas numa só. Por exemplo, se você tentar incrementar a quantidade de itens mais que uma vez no mesmo ciclo, isto resultará no equivalente a:
 
 ```javaScript
 Object.assign(
@@ -555,7 +555,7 @@ Object.assign(
 )
 ```
 
-Subsequent calls will override values from previous calls in the same cycle, so the quantity will only be incremented once. If the next state depends on the current state, we recommend using the updater function form, instead:
+Chamadas subsequentes irão sobrescrever valores de chamadas anteriores no mesmo ciclo, então a quantidade será incrementada somente uma vez. Se o próximo estado depende do estado atual, recomendamos utilizar a função *updater* como alternativa:
 
 ```js
 this.setState((state) => {
@@ -563,11 +563,11 @@ this.setState((state) => {
 });
 ```
 
-For more detail, see:
+Para mais informações, veja:
 
-* [State and Lifecycle guide](/docs/state-and-lifecycle.html)
-* [In depth: When and why are `setState()` calls batched?](https://stackoverflow.com/a/48610973/458193)
-* [In depth: Why isn't `this.state` updated immediately?](https://github.com/facebook/react/issues/11527#issuecomment-360199710)
+* [Guia de State e Lifecycle](/docs/state-and-lifecycle.html)
+* [Em detalhes: Quando e por que `setState()` agrupa chamadas?](https://stackoverflow.com/a/48610973/458193)
+* [Em detalhes: por que o `this.state` é atualizado imediatamente?](https://github.com/facebook/react/issues/11527#issuecomment-360199710)
 
 * * *
 

From 3a3ab159ce19c9cb60469426a8695c6158e9845d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Renato=20B=C3=B6hler?= <renato.bohler@gmail.com>
Date: Thu, 21 Feb 2019 19:28:33 -0300
Subject: [PATCH 36/54] translates forceUpdate section in
 reference-react-component

---
 content/docs/reference-react-component.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index ff446f921..2c4eec5d3 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -577,11 +577,11 @@ Para mais informações, veja:
 component.forceUpdate(callback)
 ```
 
-By default, when your component's state or props change, your component will re-render. If your `render()` method depends on some other data, you can tell React that the component needs re-rendering by calling `forceUpdate()`.
+Por padrão, quando o *state* ou as *props* do seu componente são alteradas, seu componente renderizará novamente. Caso seu método `render()` dependa de algum outro dado, você pode informar ao React que o componente precisa de uma rerenderização chamando `forceUpdate()`.
 
-Calling `forceUpdate()` will cause `render()` to be called on the component, skipping `shouldComponentUpdate()`. This will trigger the normal lifecycle methods for child components, including the `shouldComponentUpdate()` method of each child. React will still only update the DOM if the markup changes.
+Chamar `forceUpdate()` acarretará numa chamada de `render()` no componente, escapando `shouldComponentUpdate()`. Os métodos normais do lifecycle para os componentes filho serão chamados, incluindo o método `shouldComponentUpdate()` de cada filho. O React ainda irá atualizar o *DOM* caso realmente haja mudanças.
 
-Normally you should try to avoid all uses of `forceUpdate()` and only read from `this.props` and `this.state` in `render()`.
+Norlmalmente, você deveria tentar evitar o uso de `forceUpdate()` e somente ler de `this.props` e `this.state` em `render()`.
 
 * * *
 

From 93444e0431a4e71818f57798868156249f119534 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Renato=20B=C3=B6hler?= <renato.bohler@gmail.com>
Date: Thu, 21 Feb 2019 19:30:45 -0300
Subject: [PATCH 37/54] translates defaultProps section in
 reference-react-component

---
 content/docs/reference-react-component.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index 2c4eec5d3..d48116b6e 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -589,7 +589,7 @@ Norlmalmente, você deveria tentar evitar o uso de `forceUpdate()` e somente ler
 
 ### `defaultProps` {#defaultprops}
 
-`defaultProps` can be defined as a property on the component class itself, to set the default props for the class. This is used for undefined props, but not for null props. For example:
+`defaultProps` pode ser definido como uma propriedade do *component class*, para definir as *props* padrão para a classe. Isto é aplicado a *props* cujo valor é `undefined`, mas não para `null`. Por exemplo:
 
 ```js
 class CustomButton extends React.Component {
@@ -601,19 +601,19 @@ CustomButton.defaultProps = {
 };
 ```
 
-If `props.color` is not provided, it will be set by default to `'blue'`:
+Se `props.color` não for informado, o seu valor será definido como `'blue'`:
 
 ```js
   render() {
-    return <CustomButton /> ; // props.color will be set to blue
+    return <CustomButton /> ; // props.color será definido como 'blue'
   }
 ```
 
-If `props.color` is set to null, it will remain null:
+Se `props.color` for igual a `null`, continuará como `null`:
 
 ```js
   render() {
-    return <CustomButton color={null} /> ; // props.color will remain null
+    return <CustomButton color={null} /> ; // props.color continuará null
   }
 ```
 

From dc8ca7766a28073b6a41aebd480dd554becb79a1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Renato=20B=C3=B6hler?= <renato.bohler@gmail.com>
Date: Thu, 21 Feb 2019 19:34:00 -0300
Subject: [PATCH 38/54] translates displayName section in
 reference-react-component

---
 content/docs/reference-react-component.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index d48116b6e..f1a615a26 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -621,7 +621,7 @@ Se `props.color` for igual a `null`, continuará como `null`:
 
 ### `displayName` {#displayname}
 
-The `displayName` string is used in debugging messages. Usually, you don't need to set it explicitly because it's inferred from the name of the function or class that defines the component. You might want to set it explicitly if you want to display a different name for debugging purposes or when you create a higher-order component, see [Wrap the Display Name for Easy Debugging](/docs/higher-order-components.html#convention-wrap-the-display-name-for-easy-debugging) for details.
+A *string* `displayName` é utilizada em mensagens de depuração. Normalmente, você não precisa defini-la explicitamente, pois é isto é inferido do nome da função ou classe que definem o componente. Você pode querer defini-la explicitamente se quiser exibir um nome diferente para propósitos de depuração ou quando você cria um *higher-order component*. Veja [Envolva o Display Name para Facilitar a Depuração](/docs/higher-order-components.html#convention-wrap-the-display-name-for-easy-debugging) para mais detalhes.
 
 * * *
 

From 150988c4d783e2a156d0e657a6290b43d52073b5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Renato=20B=C3=B6hler?= <renato.bohler@gmail.com>
Date: Thu, 21 Feb 2019 19:35:37 -0300
Subject: [PATCH 39/54] translates props section in reference-react-component

---
 content/docs/reference-react-component.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index f1a615a26..81192c656 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -629,9 +629,9 @@ A *string* `displayName` é utilizada em mensagens de depuração. Normalmente,
 
 ### `props` {#props}
 
-`this.props` contains the props that were defined by the caller of this component. See [Components and Props](/docs/components-and-props.html) for an introduction to props.
+`this.props` contém as *props* que foram definidas por quem chamou este componente. Veja [Componentes e Props](/docs/components-and-props.html) para uma introdução às *props*.
 
-In particular, `this.props.children` is a special prop, typically defined by the child tags in the JSX expression rather than in the tag itself.
+Em particular, `this.props.children` é uma *prop* especial, tipicamente definida pelas *tags* filhas na expressão JSX, ao invés de na própria *tag*.
 
 ### `state` {#state}
 

From 37de829964f4d98c6409d4f9b7f13474e6e08d2a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Renato=20B=C3=B6hler?= <renato.bohler@gmail.com>
Date: Thu, 21 Feb 2019 19:38:44 -0300
Subject: [PATCH 40/54] translates state section in reference-react-component

---
 content/docs/reference-react-component.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index 81192c656..d90f18104 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -635,10 +635,10 @@ Em particular, `this.props.children` é uma *prop* especial, tipicamente definid
 
 ### `state` {#state}
 
-The state contains data specific to this component that may change over time. The state is user-defined, and it should be a plain JavaScript object.
+O *state* contém dados específicos a este componente que podem mudar com o tempo. O *state* é definido pelo usuário, e deve ser um objeto JavaScript.
 
-If some value isn't used for rendering or data flow (for example, a timer ID), you don't have to put it in the state. Such values can be defined as fields on the component instance.
+Se algum valor não for usado para renderizamento ou para controle de *data flow* (por exemplo, um *ID* de *timer*), você não precisa colocar no *state*. Tais valores podem ser definidos como campos na instância do componente.
 
-See [State and Lifecycle](/docs/state-and-lifecycle.html) for more information about the state.
+Veja [State e Lifecycle](/docs/state-and-lifecycle.html) para mais informações sobre o *state*.
 
-Never mutate `this.state` directly, as calling `setState()` afterwards may replace the mutation you made. Treat `this.state` as if it were immutable.
+Nunca mute `this.state` diretamente, pois chamar `setState()` após a mutação pode substituir a mutação realizada. Trate `this.state` como se ele fosse imutável.

From 61f4c43e1381d612350505e750ffd17029091fed Mon Sep 17 00:00:00 2001
From: Renan Silveira <renan.silveira@agrotis.com>
Date: Mon, 25 Feb 2019 12:56:13 -0300
Subject: [PATCH 41/54] =?UTF-8?q?Continua=20com=20o=20processo=20de=20trad?=
 =?UTF-8?q?u=C3=A7=C3=A3o?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 content/docs/reference-react-component.md | 52 +++++++++++------------
 1 file changed, 26 insertions(+), 26 deletions(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index 313547240..08ee57649 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -21,7 +21,7 @@ Esta página contem uma referência detalhada da API para a definição de class
 
 ## Visão Geral {#overview}
 
-React permite definirmos componentes como classes ou como funções. Componentes definidos como classes possuem mais funcionalidades que serão detalhadas nesta página. Para definir uma classe componente, ela precisa estender a classe `React.Component`:
+React permite definirmos componentes como classes (*class components*) ou como funções. Componentes definidos como classes possuem mais funcionalidades que serão detalhadas nesta página. Para definir um *class component*, a classe precisa estender `React.Component`:
 
 ```js
 class Welcome extends React.Component {
@@ -41,11 +41,11 @@ O único método que você *deve* definir em uma subclasse de `React.Component`
 >React não te obriga a utilizar a sintaxe ES6 para classes. Se preferir não usá-la, você pode usar o módulo `create-react-class` ou alguma outra abstração similar. Dê uma olhada em 
 [Usando React sem ES6](/docs/react-without-es6.html) para mais sobre este assunto.
 
-### O Ciclo de vida de um Componente {#ciclo-de-vida-de-componentes}
+### O Ciclo de vida de um Componente {#component-life-cycle}
 
 Cada componente possui muitos "métodos do ciclo de vida" que você pode sobrescrever para executar determinado código em momentos particulares do processo. **Você pode usar [este diagrama do ciclo de vida](http://projects.wojtekmaj.pl/react-lifecycle-methods-diagram/) para consulta.** Na lista abaixo, os métodos do ciclo de vida mais usados estão marcados em **negrito**. O resto deles, existe para o uso em casos relativamente raros.
 
-#### Montando {#montando}
+#### Montando {#mounting}
 
 Estes métodos são chamados na seguinte ordem quando uma instância de um componente está sendo criada e inserida no DOM:
 
@@ -61,7 +61,7 @@ Estes métodos são chamados na seguinte ordem quando uma instância de um compo
 >
 >- [`UNSAFE_componentWillMount()`](#unsafe_componentwillmount)
 
-#### Atualizando {#atualizando}
+#### Atualizando {#updating}
 
 Uma atualização pode ser causada por alterações em props ou no state. Estes métodos são chamados na seguinte ordem quando um componente esta sendo re-renderizado:
 
@@ -78,13 +78,13 @@ Uma atualização pode ser causada por alterações em props ou no state. Estes
 >- [`UNSAFE_componentWillUpdate()`](#unsafe_componentwillupdate)
 >- [`UNSAFE_componentWillReceiveProps()`](#unsafe_componentwillreceiveprops)
 
-#### Desmontando {#desmontando}
+#### Desmontando {#unmounting}
 
 Estes métodos são chamados quando um componente está sendo removido do DOM:
 
 - [**`componentWillUnmount()`**](#componentwillunmount)
 
-#### Tratando erros {#tratando-erros}
+#### Tratando erros {#terror}
 
 Estes métodos são chamados quando existir um erro durante a renderização, em um método do ciclo de vida, ou no construtor de qualquer componente-filho.
 
@@ -120,48 +120,48 @@ Os métodos desta seção cobrem a grande maioria dos casos de uso que você enc
 ```javascript
 render()
 ```
+O método `render()` é o único método obrigatório em um class-component.
 
-The `render()` method is the only required method in a class component.
+Quando chamado, ele examina `this.props` e `this.state` e retorna um dos seguintes tipos:
 
-When called, it should examine `this.props` and `this.state` and return one of the following types:
+- **Elementos React.** Tipicamente criados via [JSX](/docs/introducing-jsx.html). Por exemplo, `<div />` e `<MyComponent />` são elementos React que instruem o React para renderizar um nó do DOM, ou outro componente definido pelo usuário, respectivamente.
+- **Arrays e fragmentos.** Permitem que você retorne múltiplos elementos ao renderizar. Veja a documentação em [fragments](/docs/fragments.html) para mais detalhes.
+- **Portals**. Permitem que você renderize componentes-filhos em uma sub-árvore diferente do DOM. Veja a documentação em [portals](/docs/portals.html) para mais detalhes.
+- **String e números.** Estes são renderizados como nós de texto no DOM.
+- **Booleanos ou `null`**. Não renderizam nada.(A maioria existe para suportar  o padrão `return test && <Child />` , onde `test` é um booleano.)
 
-- **React elements.** Typically created via [JSX](/docs/introducing-jsx.html). For example, `<div />` and `<MyComponent />` are React elements that instruct React to render a DOM node, or another user-defined component, respectively.
-- **Arrays and fragments.** Let you return multiple elements from render. See the documentation on [fragments](/docs/fragments.html) for more details.
-- **Portals**. Let you render children into a different DOM subtree. See the documentation on [portals](/docs/portals.html) for more details.
-- **String and numbers.** These are rendered as text nodes in the DOM.
-- **Booleans or `null`**. Render nothing. (Mostly exists to support `return test && <Child />` pattern, where `test` is boolean.)
+A função `render()` deve ser pura, o que significa que ela não modifica o state, ela retorna o mesmo resultado a cada vez que é chamada, e isso não interage diretamente com o browser.
+Se você precisar interagir com o browser, faça isto no método `componentDidMount()` ou em outros métodos do ciclo de vida. Manter `render()` puro faz com que os componentes sejam fáceis de se trabalhar.
 
-The `render()` function should be pure, meaning that it does not modify component state, it returns the same result each time it's invoked, and it does not directly interact with the browser.
 
-If you need to interact with the browser, perform your work in `componentDidMount()` or the other lifecycle methods instead. Keeping `render()` pure makes components easier to think about.
-
-> Note
+> Nota
 >
-> `render()` will not be invoked if [`shouldComponentUpdate()`](#shouldcomponentupdate) returns false.
+> `render()` não será invocado se  [`shouldComponentUpdate()`](#shouldcomponentupdate) retornar false.
 
 * * *
 
-### `constructor()` {#constructor}
+### `construtor()` {#constructor}
 
 ```javascript
 constructor(props)
 ```
 
-**If you don't initialize state and you don't bind methods, you don't need to implement a constructor for your React component.**
+**Se você não inicializar o state e não fizer o bind dos métodos, você não precisa implementar um construtor para seu componente**
 
-The constructor for a React component is called before it is mounted. When implementing the constructor for a `React.Component` subclass, you should call `super(props)` before any other statement. Otherwise, `this.props` will be undefined in the constructor, which can lead to bugs.
+O construtor para um componente React é chamado antes que este componente seja montado. Quando estiver implementando o construtor para uma subclasse de `React.Component`, você deveria chamar `super(props)` antes de qualquer outra coisa.
+Caso contrário `this.props` será indefinido no construtor, o que pode levar a bugs.
 
-Typically, in React constructors are only used for two purposes:
+Tipicametne, em React, os construtores são usados somente para dois propósitos:
 
-* Initializing [local state](/docs/state-and-lifecycle.html) by assigning an object to `this.state`.
-* Binding [event handler](/docs/handling-events.html) methods to an instance.
+* Inicializar [local state](/docs/state-and-lifecycle.html) através da atribuição de um objeto a `this.state`.
+* Ligação (binding)  de um método [manipulador de eventos](/docs/handling-events.html) à uma instância.
 
-You **should not call `setState()`** in the `constructor()`. Instead, if your component needs to use local state, **assign the initial state to `this.state`** directly in the constructor:
+Você **não deve chamar `setState()`**  no `constructor()`. Ao invés disso, se seu componente precisa de local state, **atribua o initial state à `this.state`** diretamente no construtor:
 
 ```js
 constructor(props) {
   super(props);
-  // Don't call this.setState() here!
+  // Não chame this.setState() aqui!
   this.state = { counter: 0 };
   this.handleClick = this.handleClick.bind(this);
 }

From bac097bc8853c448323e07149dd35fbba137085f Mon Sep 17 00:00:00 2001
From: rcantuario <r.cantuario@gmail.com>
Date: Tue, 26 Feb 2019 00:01:10 -0300
Subject: [PATCH 42/54] translating life cycle methods

---
 content/docs/reference-react-component.md | 75 +++++++++++------------
 1 file changed, 37 insertions(+), 38 deletions(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index 8dcd6b198..c60a3af87 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -151,10 +151,10 @@ constructor(props)
 O construtor para um componente React é chamado antes que este componente seja montado. Quando estiver implementando o construtor para uma subclasse de `React.Component`, você deveria chamar `super(props)` antes de qualquer outra coisa.
 Caso contrário `this.props` será indefinido no construtor, o que pode levar a bugs.
 
-Tipicametne, em React, os construtores são usados somente para dois propósitos:
+Tipicamente, em React, os construtores são usados somente para dois propósitos:
 
 * Inicializar [local state](/docs/state-and-lifecycle.html) através da atribuição de um objeto a `this.state`.
-* Ligação (binding)  de um método [manipulador de eventos](/docs/handling-events.html) à uma instância.
+* Ligação (binding) de um método [manipulador de eventos](/docs/handling-events.html) à uma instância.
 
 Você **não deve chamar `setState()`**  no `constructor()`. Ao invés disso, se seu componente precisa de local state, **atribua o initial state à `this.state`** diretamente no construtor:
 
@@ -166,29 +166,27 @@ constructor(props) {
   this.handleClick = this.handleClick.bind(this);
 }
 ```
+O método consturtor é o único lugar onde você deve atribuir `this.state` diretamente. Em todos os outros métodos, você precisa usar `this.setState()`.
 
-Constructor is the only place where you should assign `this.state` directly. In all other methods, you need to use `this.setState()` instead.
+Evite introduzir qualquer efeito colateral no construtor. Para estes casos use `componentDidMount()`.
 
-Avoid introducing any side-effects or subscriptions in the constructor. For those use cases, use `componentDidMount()` instead.
-
->Note
+>Nota
 >
->**Avoid copying props into state! This is a common mistake:**
+>**Evite copiar props no state! Este é um erro comum:**
 >
 >```js
 >constructor(props) {
 >  super(props);
->  // Don't do this!
+>  // Não faça isso!
 >  this.state = { color: props.color };
 >}
 >```
 >
->The problem is that it's both unnecessary (you can use `this.props.color` directly instead), and creates bugs (updates to the `color` prop won't be reflected in the state).
+>O problema é que isto é desnecessário (você pode usar `this.props.color` diretamente), e cria bugs (atualizações em `color` não serão refletidas no state).
 >
->**Only use this pattern if you intentionally want to ignore prop updates.** In that case, it makes sense to rename the prop to be called `initialColor` or `defaultColor`. You can then force a component to "reset" its internal state by [changing its `key`](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-uncontrolled-component-with-a-key) when necessary.
+>**Use este pattern somente se você quiser ignorar atualizações em props intencionalmente.** Neste caso, faz sentido renomear a prop para ser chamada `initialColor` ou `defaultColor`. É possível então forçar um componente a "resetar" seu state interno através de  [mudando sua `chave`](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-uncontrolled-component-with-a-key) quando necessário.
 >
->Read our [blog post on avoiding derived state](/blog/2018/06/07/you-probably-dont-need-derived-state.html) to learn about what to do if you think you need some state to depend on the props.
-
+>Leia nosso [post no blog sobre evitar derivações no state](/blog/2018/06/07/you-probably-dont-need-derived-state.html) para aprender sobre o que fazer se você acha que precisa que o state dependa das props.
 
 * * *
 
@@ -198,11 +196,11 @@ Avoid introducing any side-effects or subscriptions in the constructor. For thos
 componentDidMount()
 ```
 
-`componentDidMount()` is invoked immediately after a component is mounted (inserted into the tree). Initialization that requires DOM nodes should go here. If you need to load data from a remote endpoint, this is a good place to instantiate the network request.
+`componentDidMount()` É invocado imediatamente após um componente ser montado (inserido na árvore). Inicializações que exijam nós do DOM devem vir aqui. Se precisar carregar data de um endpoint remoto, este é um bom lugar para instanciar sua requisição.
 
-This method is a good place to set up any subscriptions. If you do that, don't forget to unsubscribe in `componentWillUnmount()`.
+Este método é um bom lugar para colocar qualquer subscrição. Se fizer isto, não esqueça de desinscrever no `componentWillUnmount()`.
 
-You **may call `setState()` immediately** in `componentDidMount()`. It will trigger an extra rendering, but it will happen before the browser updates the screen. This guarantees that even though the `render()` will be called twice in this case, the user won't see the intermediate state. Use this pattern with caution because it often causes performance issues. In most cases, you should be able to assign the initial state in the `constructor()` instead. It can, however, be necessary for cases like modals and tooltips when you need to measure a DOM node before rendering something that depends on its size or position.
+Você **pode chamar `setState()` diretamente** dentro do `componentDidMount()`. Ele irá disparar uma renderização extra, mas isto irá ocorrer antes que o browser atualize a tela. Isso garante que mesmo que o `render()` seja chamado duas vezes neste caso, o usuário não verá o state intermediário. Use este pattern com cuidado porque isto frequentemente causa issues de performance. Na maioria dos casos, você deve atribuir o initial state no `constructor()`. Isto pode, no entanto, ser necessário para casos como modais e tooltips quando você precisa mensurar um nó do DOM antes de renderizar algo que dependa de seu tamanho ou posição.
 
 * * *
 
@@ -212,26 +210,26 @@ You **may call `setState()` immediately** in `componentDidMount()`. It will trig
 componentDidUpdate(prevProps, prevState, snapshot)
 ```
 
-`componentDidUpdate()` is invoked immediately after updating occurs. This method is not called for the initial render.
+`componentDidUpdate()` é invocado imediatamente após alguma atualização ocorrer. Este método não é chamado pelo initial render.
 
-Use this as an opportunity to operate on the DOM when the component has been updated. This is also a good place to do network requests as long as you compare the current props to previous props (e.g. a network request may not be necessary if the props have not changed).
+Use isto como uma oportunidade para alterar o DOM quando o componente for atualizado. Este também é um bom lugar para realizar requisições de rede enquanto compara as props atuais com as props anteriores (e.g. uma chamada de rede pode não ser necessária se as props não mudaram).
 
 ```js
 componentDidUpdate(prevProps) {
-  // Typical usage (don't forget to compare props):
+  // Uso típico, (não esqueça de comparar as props):
   if (this.props.userID !== prevProps.userID) {
     this.fetchData(this.props.userID);
   }
 }
 ```
 
-You **may call `setState()` immediately** in `componentDidUpdate()` but note that **it must be wrapped in a condition** like in the example above, or you'll cause an infinite loop. It would also cause an extra re-rendering which, while not visible to the user, can affect the component performance. If you're trying to "mirror" some state to a prop coming from above, consider using the prop directly instead. Read more about [why copying props into state causes bugs](/blog/2018/06/07/you-probably-dont-need-derived-state.html).
+Você **pode chamar `setState()` imediatamente** dentro do `componentDidUpdate()` mas perceba que **isto deve estar encapsulado em uma condição** como no exemplo abaixp, ou você irá causar um loop infinito. Isto também causaria uma re-renderização extra, que por mais que não seja visível para o usuário pode afetar a performance do componente. Se você está tentando "espelhar" algum state para uma prop vinda de cima, considere usar a prop diretamente. Leia mais sobre [porque copiar props no state causa bugs](/blog/2018/06/07/you-probably-dont-need-derived-state.html).
 
-If your component implements the `getSnapshotBeforeUpdate()` lifecycle (which is rare), the value it returns will be passed as a third "snapshot" parameter to `componentDidUpdate()`. Otherwise this parameter will be undefined.
+Se seu componente implementa o método `getSnapshotBeforeUpdate()` (o que é raro), o valor que ele retorna será passado como o terceiro parâmetro "snapshot" para `componentDidUpdate()`. Caso contrário este parâmetro será undefined.
 
-> Note
+> Nota
 >
-> `componentDidUpdate()` will not be invoked if [`shouldComponentUpdate()`](#shouldcomponentupdate) returns false.
+> `componentDidUpdate()` não será invocado se [`shouldComponentUpdate()`](#shouldcomponentupdate) retornar false.
 
 * * *
 
@@ -241,15 +239,15 @@ If your component implements the `getSnapshotBeforeUpdate()` lifecycle (which is
 componentWillUnmount()
 ```
 
-`componentWillUnmount()` is invoked immediately before a component is unmounted and destroyed. Perform any necessary cleanup in this method, such as invalidating timers, canceling network requests, or cleaning up any subscriptions that were created in `componentDidMount()`.
+`componentWillUnmount()` é invocado imediatamente antes que um componente seja desmontado e destruído. Qualquer limpeza necessária deve ser realizada neste método, como invalidar timers, cancelar requisições de rede, ou limpar qualquer subscrição que foi criada no `componentDidMount()`.
 
-You **should not call `setState()`** in `componentWillUnmount()` because the component will never be re-rendered. Once a component instance is unmounted, it will never be mounted again.
+**Não se deve chamar `setState()`** em `componentWillUnmount()` Porque o componente nunca irá será renderizado novametne. Uma vez que a instância do componente foi desmontada, ela nunca será montada novamente.
 
 * * *
 
-### Rarely Used Lifecycle Methods {#rarely-used-lifecycle-methods}
+### Métodos raramente usados {#rarely-used-lifecycle-methods}
 
-The methods in this section correspond to uncommon use cases. They're handy once in a while, but most of your components probably don't need any of them. **You can see most of the methods below on [this lifecycle diagram](http://projects.wojtekmaj.pl/react-lifecycle-methods-diagram/) if you click the "Show less common lifecycles" checkbox at the top of it.**
+Estes métodos desa seção correspondem a casos de uso incomuns. Eles são úteis de vez em quando, mas na maioria das vezes, seus componentes provavelmente não irão precisar de nenhum deles. **Pode ver a maioria dos métodos abaixo [neste diagrama do ciclo de vida](http://projects.wojtekmaj.pl/react-lifecycle-methods-diagram/) se clicar na checkbox"Show less common lifecycles" no topo da página.**
 
 
 ### `shouldComponentUpdate()` {#shouldcomponentupdate}
@@ -258,17 +256,18 @@ The methods in this section correspond to uncommon use cases. They're handy once
 shouldComponentUpdate(nextProps, nextState)
 ```
 
-Use `shouldComponentUpdate()` to let React know if a component's output is not affected by the current change in state or props. The default behavior is to re-render on every state change, and in the vast majority of cases you should rely on the default behavior.
+Use `shouldComponentUpdate()` para permitir que o React saiba se o resultado de um componente não é afetdo pelas mudanças atuais em state ou props. O comportamento padrão é para re-renderizar a cada mudança do state, e na grande maioria dos casos você deve confiar no comportamento padrão.
 
-`shouldComponentUpdate()` is invoked before rendering when new props or state are being received. Defaults to `true`. This method is not called for the initial render or when `forceUpdate()` is used.
+`shouldComponentUpdate()` é invoado antes do rendring quando novas props ou state são recebigos. O valor default é `true`. Este método não é chamado na renderização inicial ou quando `forceUpdate()`é usado .
 
-This method only exists as a **[performance optimization](/docs/optimizing-performance.html).** Do not rely on it to "prevent" a rendering, as this can lead to bugs. **Consider using the built-in [`PureComponent`](/docs/react-api.html#reactpurecomponent)** instead of writing `shouldComponentUpdate()` by hand. `PureComponent` performs a shallow comparison of props and state, and reduces the chance that you'll skip a necessary update.
+Este método existe somente para **[otimização de performance ](/docs/optimizing-performance.html).** Não confie nele para "evitar" a renderização, pois isso pode levar a bugs. **Considere usar [`PureComponent`](/docs/react-api.html#reactpurecomponent)** no lugar de escrever `shouldComponentUpdate()` manualmente. `PureComponent` realiza uma comparação superficial das props e do state, e reduz as chances the pular um update necessário.
 
-If you are confident you want to write it by hand, you may compare `this.props` with `nextProps` and `this.state` with `nextState` and return `false` to tell React the update can be skipped. Note that returning `false` does not prevent child components from re-rendering when *their* state changes.
+Se você está confiante que quer escrever isto manualmente, pode comparar `this.props` com `nextProps` e `this.state` com `nextState`
+e retornar `false` para informar o React que o update pode ser pulado. Perceba que retornando `false` não evita que componentes filhos sejam renderizados novamente quando o state *deles* sofrer alterações.
 
-We do not recommend doing deep equality checks or using `JSON.stringify()` in `shouldComponentUpdate()`. It is very inefficient and will harm performance.
+Não recomendamos fazer verificações de igualdade profundas ou usar `JSON.stringify()` dentro de `shouldComponentUpdate()`. Isto é ineficiente e irá prejudicar a performance.
 
-Currently, if `shouldComponentUpdate()` returns `false`, then [`UNSAFE_componentWillUpdate()`](#unsafe_componentwillupdate), [`render()`](#render), and [`componentDidUpdate()`](#componentdidupdate) will not be invoked. In the future React may treat `shouldComponentUpdate()` as a hint rather than a strict directive, and returning `false` may still result in a re-rendering of the component.
+Atualmente, se `shouldComponentUpdate()` retornar `false`, então [`UNSAFE_componentWillUpdate()`](#unsafe_componentwillupdate), [`render()`](#render), e [`componentDidUpdate()`](#componentdidupdate) não serão invocados. No futuro, React pode tratar  `shouldComponentUpdate()` como uma dica ao invés de uma rigorosa diretiva. e retornar `false` pode continuar resultando em re-renderização do componente.
 
 * * *
 
@@ -278,16 +277,16 @@ Currently, if `shouldComponentUpdate()` returns `false`, then [`UNSAFE_component
 static getDerivedStateFromProps(props, state)
 ```
 
-`getDerivedStateFromProps` is invoked right before calling the render method, both on the initial mount and on subsequent updates. It should return an object to update the state, or null to update nothing.
+`getDerivedStateFromProps` é invocado imediatamente antes de chamar o método render, ambos na montagem inicial e nas atualizações subsequente. Devem retornar um objeto para atualizar o state, ou null para não atualizar nada.
 
-This method exists for [rare use cases](/blog/2018/06/07/you-probably-dont-need-derived-state.html#when-to-use-derived-state) where the state depends on changes in props over time. For example, it might be handy for implementing a `<Transition>` component that compares its previous and next children to decide which of them to animate in and out.
+Este método existe para [casos de uso raros] (/blog/2018/06/07/you-probably-dont-need-derived-state.html#when-to-use-derived-state) onde o state depende de mudanças nas props ao longo do tempo. Por exemplo, pode ser útil para implementar um componente `<Transition>` que compara seus filhos anteriores e próimos para decidir quais deles devem ser animados.
 
-Deriving state leads to verbose code and makes your components difficult to think about.  
-[Make sure you're familiar with simpler alternatives:](/blog/2018/06/07/you-probably-dont-need-derived-state.html)
+Derivando o state leva a código verboso e faz seus componentes difíceis de compreender.
+[Tenha certeza de estar familiarizado com alternativas mais simples:](/blog/2018/06/07/you-probably-dont-need-derived-state.html)
 
-* If you need to **perform a side effect** (for example, data fetching or an animation) in response to a change in props, use [`componentDidUpdate`](#componentdidupdate) lifecycle instead.
+* Se precisar  **perform a side effect** (por exemplo, buscar dados ou uma animação) em resposta a uma alteração em props, use [`componentDidUpdate`](#componentdidupdate) no lugar.
 
-* If you want to **re-compute some data only when a prop changes**, [use a memoization helper instead](/blog/2018/06/07/you-probably-dont-need-derived-state.html#what-about-memoization).
+* Se você quer **re-compute some data only when a prop changes**, [use a memoization helper instead](/blog/2018/06/07/you-probably-dont-need-derived-state.html#what-about-memoization).
 
 * If you want to **"reset" some state when a prop changes**, consider either making a component [fully controlled](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-controlled-component) or [fully uncontrolled with a `key`](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-uncontrolled-component-with-a-key) instead.
 

From 603f2e2bd33f727d85d3ba65be2dbbef605c7a5d Mon Sep 17 00:00:00 2001
From: rcantuario <r.cantuario@gmail.com>
Date: Tue, 26 Feb 2019 05:47:59 -0300
Subject: [PATCH 43/54] finishing lifecycle methods

---
 content/docs/reference-react-component.md | 27 +++++++++++++----------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index c60a3af87..a9d5c2ec7 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -84,33 +84,33 @@ Estes métodos são chamados quando um componente está sendo removido do DOM:
 
 - [**`componentWillUnmount()`**](#componentwillunmount)
 
-#### Tratando erros {#terror}
+#### Tratando erros {#handling errors}
 
 Estes métodos são chamados quando existir um erro durante a renderização, em um método do ciclo de vida, ou no construtor de qualquer componente-filho.
 
 - [`static getDerivedStateFromError()`](#static-getderivedstatefromerror)
 - [`componentDidCatch()`](#componentdidcatch)
 
-### Outras APIs {#outras-apis}
+### Outras APIs {#other-apis}
 
 Cada componente também fornece outras APIs:
 
   - [`setState()`](#setstate)
   - [`forceUpdate()`](#forceupdate)
 
-### Propriedades de Classes {#propriedades-de-classes}
+### Propriedades de Classes {#class-properties}
 
   - [`defaultProps`](#defaultprops)
   - [`displayName`](#displayname)
 
-### Propriedades da instância {#propriedades-da-instância}
+### Propriedades da instância {#instance-properties}
 
   - [`props`](#props)
   - [`state`](#state)
 
 * * *
 
-## Referencia {#referencia}
+## Referencia {#reference}
 
 ### Métodos mais usados do Ciclo de Vida {#métodos-mais-usados-do-ciclo-de-vida}
 Os métodos desta seção cobrem a grande maioria dos casos de uso que você encontrará criando componentes React. **Para uma referência visual, veja : [este diagrama do ciclo de vida](http://projects.wojtekmaj.pl/react-lifecycle-methods-diagram/).**
@@ -286,13 +286,13 @@ Derivando o state leva a código verboso e faz seus componentes difíceis de com
 
 * Se precisar  **perform a side effect** (por exemplo, buscar dados ou uma animação) em resposta a uma alteração em props, use [`componentDidUpdate`](#componentdidupdate) no lugar.
 
-* Se você quer **re-compute some data only when a prop changes**, [use a memoization helper instead](/blog/2018/06/07/you-probably-dont-need-derived-state.html#what-about-memoization).
+* Se você quer **re-compute some data only when a prop changes**, [use um auxiliar de memorização no lugar](/blog/2018/06/07/you-probably-dont-need-derived-state.html#what-about-memoization).
 
-* If you want to **"reset" some state when a prop changes**, consider either making a component [fully controlled](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-controlled-component) or [fully uncontrolled with a `key`](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-uncontrolled-component-with-a-key) instead.
+* ISe você quer **"resetar" o state quando uma prop mudar**, considere criar um componente [completamente controlado](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-controlled-component) ou [completamente controlado com uma `chave`](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-uncontrolled-component-with-a-key) instead.
 
-This method doesn't have access to the component instance. If you'd like, you can reuse some code between `getDerivedStateFromProps()` and the other class methods by extracting pure functions of the component props and state outside the class definition.
+Este método não potem acesso a instância do componente. Se você quiser, pode reusar o código entre o método `getDerivedStateFromProps()` e os métodos de outra classe extraindo funções puras para as props e state do componente, fora da definição da classe.
 
-Note that this method is fired on *every* render, regardless of the cause. This is in contrast to `UNSAFE_componentWillReceiveProps`, which only fires when the parent causes a re-render and not as a result of a local `setState`.
+Perceba que este método é disparado a *cada* renderização, independentemente da razão. Isto está em contraste com  `UNSAFE_componentWillReceiveProps`, que dispara somente quando um componente pai causa uma re-renderização e não como resultado de uma chamada local a `setState`.
 
 * * *
 
@@ -302,18 +302,21 @@ Note that this method is fired on *every* render, regardless of the cause. This
 getSnapshotBeforeUpdate(prevProps, prevState)
 ```
 
-`getSnapshotBeforeUpdate()` is invoked right before the most recently rendered output is committed to e.g. the DOM. It enables your component to capture some information from the DOM (e.g. scroll position) before it is potentially changed. Any value returned by this lifecycle will be passed as a parameter to `componentDidUpdate()`.
+`getSnapshotBeforeUpdate()` é invocado imediatamente antes que o retorno da renderização mais recente seja escrito e.g. no DOM. Isto permite que o componente capture alguma informação do DOM (e.g. posição do scroll) antes que ela seja potencialmente alterada. Qualquer valor retornado por este método do ciclo de vida será passado como parâmetro para `componentDidUpdate()`.
 
-This use case is not common, but it may occur in UIs like a chat thread that need to handle scroll position in a special way.
+Este caso de uso não é comum, mas pode ocorrer em UIs como um thread de um chat que precise tratar a posição do scroll de uma maneira especial.
 
 A snapshot value (or `null`) should be returned.
+O valor do snapshot (ou `null`) deve ser retornado
 
-For example:
+Por exemplo:
 
 `embed:react-component-reference/get-snapshot-before-update.js`
 
 In the above examples, it is important to read the `scrollHeight` property in `getSnapshotBeforeUpdate` because there may be delays between "render" phase lifecycles (like `render`) and "commit" phase lifecycles (like `getSnapshotBeforeUpdate` and `componentDidUpdate`).
 
+No exemplo acima, é importante lermos a propriedade `scrollHeight` em `getSnapshotBeforeUpdate` porque podem ocorrer delays entre a fase do ciclo de vida "renderização"  (`render`) e a fase "commit" (commit `getSnapshotBeforeUpdate` e `componentDidUpdate`).
+
 * * *
 
 ### Error boundaries {#error-boundaries}

From 833af9d49a51172bf0a1655d1688d26ea44507ce Mon Sep 17 00:00:00 2001
From: Glaucia Lemos <glaucia_lemos86@hotmail.com>
Date: Wed, 27 Feb 2019 22:57:50 -0300
Subject: [PATCH 44/54] Update content/docs/reference-react-component.md

Co-Authored-By: rcantuario <r.cantuario@gmail.com>
---
 content/docs/reference-react-component.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index a9d5c2ec7..7e7b2fb30 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -84,7 +84,7 @@ Estes métodos são chamados quando um componente está sendo removido do DOM:
 
 - [**`componentWillUnmount()`**](#componentwillunmount)
 
-#### Tratando erros {#handling errors}
+#### Tratando erros {#error-handling}
 
 Estes métodos são chamados quando existir um erro durante a renderização, em um método do ciclo de vida, ou no construtor de qualquer componente-filho.
 

From ee8759212586504739190904d88f54d17edfcfcf Mon Sep 17 00:00:00 2001
From: Glaucia Lemos <glaucia_lemos86@hotmail.com>
Date: Wed, 27 Feb 2019 22:58:42 -0300
Subject: [PATCH 45/54] Update content/docs/reference-react-component.md

Co-Authored-By: rcantuario <r.cantuario@gmail.com>
---
 content/docs/reference-react-component.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index 7e7b2fb30..5b02c0c3b 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -130,7 +130,7 @@ Quando chamado, ele examina `this.props` e `this.state` e retorna um dos seguint
 - **String e números.** Estes são renderizados como nós de texto no DOM.
 - **Booleanos ou `null`**. Não renderizam nada.(A maioria existe para suportar  o padrão `return test && <Child />` , onde `test` é um booleano.)
 
-A função `render()` deve ser pura, o que significa que ela não modifica o state, ela retorna o mesmo resultado a cada vez que é chamada, e isso não interage diretamente com o browser.
+A função `render()` deve ser pura, o que significa que ela não modifica o state. Pois, ela retorna o mesmo resultado a cada vez que é chamada e isso não interage diretamente com o browser.
 Se você precisar interagir com o browser, faça isto no método `componentDidMount()` ou em outros métodos do ciclo de vida. Manter `render()` puro faz com que os componentes sejam fáceis de se trabalhar.
 
 

From bbf937ec3fb7b56eea2047f301dafd8b69f97e85 Mon Sep 17 00:00:00 2001
From: Glaucia Lemos <glaucia_lemos86@hotmail.com>
Date: Wed, 27 Feb 2019 22:59:15 -0300
Subject: [PATCH 46/54] Update content/docs/reference-react-component.md

Co-Authored-By: rcantuario <r.cantuario@gmail.com>
---
 content/docs/reference-react-component.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index 5b02c0c3b..2c3784d5d 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -151,7 +151,7 @@ constructor(props)
 O construtor para um componente React é chamado antes que este componente seja montado. Quando estiver implementando o construtor para uma subclasse de `React.Component`, você deveria chamar `super(props)` antes de qualquer outra coisa.
 Caso contrário `this.props` será indefinido no construtor, o que pode levar a bugs.
 
-Tipicamente, em React, os construtores são usados somente para dois propósitos:
+Normalmente, em React, os construtores são usados somente para dois propósitos:
 
 * Inicializar [local state](/docs/state-and-lifecycle.html) através da atribuição de um objeto a `this.state`.
 * Ligação (binding) de um método [manipulador de eventos](/docs/handling-events.html) à uma instância.

From d9daaefc927f85f9f4d5ab1b176fb0dd8446ec69 Mon Sep 17 00:00:00 2001
From: Glaucia Lemos <glaucia_lemos86@hotmail.com>
Date: Wed, 27 Feb 2019 22:59:53 -0300
Subject: [PATCH 47/54] Update content/docs/reference-react-component.md

Co-Authored-By: rcantuario <r.cantuario@gmail.com>
---
 content/docs/reference-react-component.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index 2c3784d5d..de4afe502 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -546,7 +546,7 @@ Isto realiza uma mescla superficial de `stateChange` dentro no novo *state*. Por
 this.setState({quantity: 2})
 ```
 
-Esta forma de `setState()` também é assíncrona, e múltiplas chamadas durante o mesmo ciclo podem ser agrupadas numa só. Por exemplo, se você tentar incrementar a quantidade de itens mais que uma vez no mesmo ciclo, isto resultará no equivalente a:
+Esta forma de `setState()` também é assíncrona e múltiplas chamadas durante o mesmo ciclo podem ser agrupadas numa só. Por exemplo, se você tentar incrementar a quantidade de itens mais que uma vez no mesmo ciclo, isto resultará no equivalente a:
 
 ```javaScript
 Object.assign(

From 8973bf40d7811af02fcae3720c1655433712d7e9 Mon Sep 17 00:00:00 2001
From: Glaucia Lemos <glaucia_lemos86@hotmail.com>
Date: Wed, 27 Feb 2019 23:00:48 -0300
Subject: [PATCH 48/54] Update content/docs/reference-react-component.md

Alterando conforme sugerido pela @glaucia86

Co-Authored-By: rcantuario <r.cantuario@gmail.com>
---
 content/docs/reference-react-component.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index de4afe502..72b081537 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -557,7 +557,7 @@ Object.assign(
 )
 ```
 
-Chamadas subsequentes irão sobrescrever valores de chamadas anteriores no mesmo ciclo, então a quantidade será incrementada somente uma vez. Se o próximo estado depende do estado atual, recomendamos utilizar a função *updater* como alternativa:
+Chamadas subsequentes irão sobrescrever valores de chamadas anteriores no mesmo ciclo. Com isso, a quantidade será incrementada somente uma vez. Se o próximo estado depende do estado atual, recomendamos utilizar a função *updater* como alternativa:
 
 ```js
 this.setState((state) => {

From fb231a60f4fb107c40bdf57b1523410ffbe23c78 Mon Sep 17 00:00:00 2001
From: Glaucia Lemos <glaucia_lemos86@hotmail.com>
Date: Wed, 27 Feb 2019 23:01:53 -0300
Subject: [PATCH 49/54] Update content/docs/reference-react-component.md

Alterando conforme sugerido pela @glaucia86

Co-Authored-By: rcantuario <r.cantuario@gmail.com>
---
 content/docs/reference-react-component.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index 72b081537..3d0c23669 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -623,7 +623,7 @@ Se `props.color` for igual a `null`, continuará como `null`:
 
 ### `displayName` {#displayname}
 
-A *string* `displayName` é utilizada em mensagens de depuração. Normalmente, você não precisa defini-la explicitamente, pois é isto é inferido do nome da função ou classe que definem o componente. Você pode querer defini-la explicitamente se quiser exibir um nome diferente para propósitos de depuração ou quando você cria um *higher-order component*. Veja [Envolva o Display Name para Facilitar a Depuração](/docs/higher-order-components.html#convention-wrap-the-display-name-for-easy-debugging) para mais detalhes.
+A *string* `displayName` é utilizada em mensagens de depuração. Normalmente, você não precisa defini-la explicitamente. Pois isto é inferido do nome da função ou classe que definem o componente. Você pode querer defini-la explicitamente se quiser exibir um nome diferente para propósitos de depuração ou quando você cria um *higher-order component*. Veja [Envolva o Display Name para Facilitar a Depuração](/docs/higher-order-components.html#convention-wrap-the-display-name-for-easy-debugging) para mais detalhes.
 
 * * *
 

From 012bb2b68b0e20a88e8ef4b00b0bc40999509c99 Mon Sep 17 00:00:00 2001
From: Glaucia Lemos <glaucia_lemos86@hotmail.com>
Date: Wed, 27 Feb 2019 23:03:05 -0300
Subject: [PATCH 50/54] Update content/docs/reference-react-component.md

Co-Authored-By: rcantuario <r.cantuario@gmail.com>
---
 content/docs/reference-react-component.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index 3d0c23669..936835355 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -637,7 +637,7 @@ Em particular, `this.props.children` é uma *prop* especial, tipicamente definid
 
 ### `state` {#state}
 
-O *state* contém dados específicos a este componente que podem mudar com o tempo. O *state* é definido pelo usuário, e deve ser um objeto JavaScript.
+O *state* contém dados específicos a este componente que podem mudar com o tempo. O *state* é definido pelo usuário e deve ser um objeto JavaScript.
 
 Se algum valor não for usado para renderizamento ou para controle de *data flow* (por exemplo, um *ID* de *timer*), você não precisa colocar no *state*. Tais valores podem ser definidos como campos na instância do componente.
 

From 48d864bd3a150bb80d0d722aab0a53190cca1173 Mon Sep 17 00:00:00 2001
From: Glaucia Lemos <glaucia_lemos86@hotmail.com>
Date: Wed, 27 Feb 2019 23:05:30 -0300
Subject: [PATCH 51/54] Update content/docs/reference-react-component.md

Alterando conforme sugerido pela @glaucia86

Co-Authored-By: rcantuario <r.cantuario@gmail.com>
---
 content/docs/reference-react-component.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index 936835355..85abf7736 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -633,7 +633,7 @@ A *string* `displayName` é utilizada em mensagens de depuração. Normalmente,
 
 `this.props` contém as *props* que foram definidas por quem chamou este componente. Veja [Componentes e Props](/docs/components-and-props.html) para uma introdução às *props*.
 
-Em particular, `this.props.children` é uma *prop* especial, tipicamente definida pelas *tags* filhas na expressão JSX, ao invés de na própria *tag*.
+Em particular, `this.props.children` é uma *prop* especial, normalmente definida pelas *tags* filhas na expressão JSX, ao invés de na própria *tag*.
 
 ### `state` {#state}
 

From 217488450a05e283b302efcaf006736ec586bde6 Mon Sep 17 00:00:00 2001
From: Jhon Mike <developer@jhonmike.com.br>
Date: Thu, 28 Feb 2019 13:23:25 -0300
Subject: [PATCH 52/54] Update content/docs/reference-react-component.md

Co-Authored-By: rcantuario <r.cantuario@gmail.com>
---
 content/docs/reference-react-component.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index 85abf7736..00cb6818a 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -16,7 +16,7 @@ redirect_from:
 ---
 
 
-Esta página contem uma referência detalhada da API para a definição de classes de componentes React. Nós assumimos que você possui familiaridade com conceitos fundamentais do React, como [Componentes e Props](/docs/components-and-props.html), bem como [State e Lifecycle](/docs/state-and-lifecycle.html). Se isto não é familiar para você, leia essas páginas primeiro.
+Esta página contém uma referência detalhada da API para a definição de classes de componentes React. Nós assumimos que você possui familiaridade com conceitos fundamentais do React, como [Componentes e Props](/docs/components-and-props.html), bem como [State e Ciclo de vida](/docs/state-and-lifecycle.html). Se isto não é familiar para você, leia essas páginas primeiro.
 
 
 ## Visão Geral {#overview}

From 3783a6b47d47c51777e3d4c07fa7c179b6aacb43 Mon Sep 17 00:00:00 2001
From: Jhon Mike <developer@jhonmike.com.br>
Date: Thu, 28 Feb 2019 13:25:05 -0300
Subject: [PATCH 53/54] Update content/docs/reference-react-component.md

Co-Authored-By: rcantuario <r.cantuario@gmail.com>
---
 content/docs/reference-react-component.md | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index 00cb6818a..555f13823 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -112,7 +112,8 @@ Cada componente também fornece outras APIs:
 
 ## Referencia {#reference}
 
-### Métodos mais usados do Ciclo de Vida {#métodos-mais-usados-do-ciclo-de-vida}
+### Métodos mais usados do Ciclo de Vida {#commonly-used-lifecycle-methods}
+
 Os métodos desta seção cobrem a grande maioria dos casos de uso que você encontrará criando componentes React. **Para uma referência visual, veja : [este diagrama do ciclo de vida](http://projects.wojtekmaj.pl/react-lifecycle-methods-diagram/).**
 
 ### `render()` {#render}

From 48c3810db1e031822e9971926a7f7f86934ecbd0 Mon Sep 17 00:00:00 2001
From: Jhon Mike <developer@jhonmike.com.br>
Date: Thu, 28 Feb 2019 13:26:14 -0300
Subject: [PATCH 54/54] Update content/docs/reference-react-component.md

Co-Authored-By: rcantuario <r.cantuario@gmail.com>
---
 content/docs/reference-react-component.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index 555f13823..6d1c74ffb 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -141,7 +141,7 @@ Se você precisar interagir com o browser, faça isto no método `componentDidMo
 
 * * *
 
-### `construtor()` {#constructor}
+### `constructor()` {#constructor}
 
 ```javascript
 constructor(props)