diff --git a/content/docs/add-react-to-a-website.md b/content/docs/add-react-to-a-website.md
index 240399e08..19ade13ca 100644
--- a/content/docs/add-react-to-a-website.md
+++ b/content/docs/add-react-to-a-website.md
@@ -57,7 +57,7 @@ Lo siguiente es agregar tres etiquetas `<script>` a la página HTML justo antes
   <script src="https://unpkg.com/react@16/umd/react.development.js" crossorigin></script>
   <script src="https://unpkg.com/react-dom@16/umd/react-dom.development.js" crossorigin></script>
 
-  <!-- Carguemos nuestro componente de React. -->
+  <!-- Cargamos nuestro componente de React. -->
   <script src="like_button.js"></script>
 
 </body>
@@ -147,7 +147,7 @@ return (
 );
 ```
 
-Estos dos fragmentos de código son equivalentes. Mientras **JSX es [completamente opcional](/docs/react-without-jsx.html)**, muchas personas lo encuentran útil para escribir código relacionado con la IU -- ya sea usando React o con otras bibliotecas.
+Estos dos fragmentos de código son equivalentes. Mientras **JSX es [completamente opcional](/docs/react-without-jsx.html)**, muchas personas lo encuentran útil para escribir código relacionado con la interfaz de usuario -- ya sea usando React o con otras bibliotecas.
 
 Puedes experimentar con JSX usando [este conversor en línea](http://babeljs.io/repl#?babili=false&browsers=&build=&builtIns=false&spec=false&loose=false&code_lz=Q&debug=false&forceAllTransforms=false&shippedProposals=false&circleciRepo=&evaluate=false&fileSize=false&sourceType=module&lineWrap=true&presets=es2015%2Creact%2Cstage-2%2Cstage-3&prettier=true&targets=Node-6.12&version=6.26.0&envVersion=).
 
diff --git a/content/docs/addons-shallow-renderer.md b/content/docs/addons-shallow-renderer.md
index 222e3c10f..9947318aa 100644
--- a/content/docs/addons-shallow-renderer.md
+++ b/content/docs/addons-shallow-renderer.md
@@ -10,7 +10,7 @@ category: Referencia
 
 ```javascript
 import ShallowRenderer from 'react-test-renderer/shallow'; // ES6
-var ShallowRenderer = require('react-test-renderer/shallow'); // ES5 with npm
+var ShallowRenderer = require('react-test-renderer/shallow'); // ES5 con npm
 ```
 
 ## Resumen {#resumen}
@@ -35,7 +35,7 @@ Entonces puedes comprobar:
 ```javascript
 import ShallowRenderer from 'react-test-renderer/shallow';
 
-// en tu test:
+// en tu prueba:
 const renderer = new ShallowRenderer();
 renderer.render(<MyComponent />);
 const result = renderer.getRenderOutput();
@@ -47,11 +47,11 @@ expect(result.props.children).toEqual([
 ]);
 ```
 
-Las pruebas superficiales tienen algunas limitaciones, es decir, no soportan refs.
+Las pruebas superficiales tienen algunas limitaciones, es decir, no soportan referencias.
 
 > Nota:
 >
-> También recomendamos revisar [Shallow Rendering API](http://airbnb.io/enzyme/docs/api/shallow.html) de Enzyme. Provee un API de alto nivel mucho mejor de la misma funcionalidad.
+> También recomendamos revisar la [API de Renderizado Superficial](http://airbnb.io/enzyme/docs/api/shallow.html) de Enzyme. Provee una API de alto nivel mucho mejor de la misma funcionalidad.
 
 ## Referencia {#referencia}
 
diff --git a/content/docs/addons-test-utils.md b/content/docs/addons-test-utils.md
index d611cb0a5..ade96ea35 100644
--- a/content/docs/addons-test-utils.md
+++ b/content/docs/addons-test-utils.md
@@ -10,7 +10,7 @@ category: Reference
 
 ```javascript
 import ReactTestUtils from 'react-dom/test-utils'; // ES6
-var ReactTestUtils = require('react-dom/test-utils'); // ES5 with npm
+var ReactTestUtils = require('react-dom/test-utils'); // ES5 con npm
 ```
 
 ## Introducción {#overview}
@@ -208,7 +208,7 @@ findAllInRenderedTree(
 )
 ```
 
-Navega por todos los componentes en `tree` y acumula todos los componentes en donde `test(component)` sea `true`. Esto no es útil por sí solo, pero es utilizado como primitivo para otras utilidades de prueba.
+Navega por todos los componentes en `tree` y acumula todos los componentes en donde `test(component)` sea `true`. Esto no es útil por sí solo, pero es utilizado como primitiva para otras utilidades de prueba.
 
 * * *
 
diff --git a/content/docs/code-splitting.md b/content/docs/code-splitting.md
index 5c6159519..5d7a7b8f5 100644
--- a/content/docs/code-splitting.md
+++ b/content/docs/code-splitting.md
@@ -202,7 +202,7 @@ const MyComponent = () => (
 
 Decidir en qué parte de tu aplicación introducir la división de código puede ser un poco complicado. Quieres asegurarte de elegir lugares que dividan los *bundles* de manera uniforme, sin interrumpir la experiencia del usuario.
 
-Un buen lugar para comenzar es con las rutas. La mayoría de la gente en la web está acostumbrada a que las transiciones entre páginas se tomen cierto tiempo en cargar. También tiendes a rerenderizar todo de una vez, así que es improbable que tus usuarios interactúen con otros elementos en la página al mismo tiempo.
+Un buen lugar para comenzar es con las rutas. La mayoría de la gente en la web está acostumbrada a que las transiciones entre páginas se tomen cierto tiempo en cargar. También tiendes a volver a renderizar todo de una vez, así que es improbable que tus usuarios interactúen con otros elementos en la página al mismo tiempo.
 
 Este es un ejemplo de cómo configurar la división de código basada en rutas en tu aplicación usando
 bibliotecas como [React Router](https://reacttraining.com/react-router/) con `React.lazy`.
diff --git a/content/docs/components-and-props.md b/content/docs/components-and-props.md
index 74c4c1d60..b25c72c9e 100644
--- a/content/docs/components-and-props.md
+++ b/content/docs/components-and-props.md
@@ -15,7 +15,7 @@ redirect_from:
 prev: rendering-elements.html
 next: state-and-lifecycle.html
 ---
-Los componentes permiten separar la UI en piezas independientes, reutilizables y pensar en cada pieza de forma aislada.Esta página proporciona una introducción a la idea de los componentes.
+Los componentes permiten separar la interfaz de usuario en piezas independientes, reutilizables y pensar en cada pieza de forma aislada.Esta página proporciona una introducción a la idea de los componentes.
 Puedes encontrar una [API detallada sobre componentes aquí](/docs/react-component.html).
 
 Conceptualmente, los componentes son como las funciones de JavaScript. Aceptan entradas arbitrarias (llamadas "props") y devuelven a React elementos que describen lo que debe aparecer en la pantalla.
@@ -61,7 +61,7 @@ Sin embargo, los elementos también pueden representar componentes definidos por
 const element = <Welcome name="Sara" />;
 ```
 
-Cuando React ve representando un componente definido por el usuario, pasa atributos JSX a este componente como un solo objeto. Llamamos a este objeto "props".
+Cuando React ve un elemento representando un componente definido por el usuario, pasa atributos JSX a este componente como un solo objeto. Llamamos a este objeto "props".
 
 Por ejemplo, este código muestra "Hello, Sara" en la página:
 
@@ -88,7 +88,7 @@ Recapitulemos lo que sucede en este ejemplo:
 
 > **Nota:** Comienza siempre los nombres de componentes con una letra mayúscula.
 > 
->React trata los componentes que empiezan con letras minúsculas como etiquetas del DOM. Por ejemplo, `<div />` representa una etiqueta div HTML pero `<Welcome />` representa un componente y requiere que `Welcome` esté en scope.
+>React trata los componentes que empiezan con letras minúsculas como etiquetas del DOM. Por ejemplo, `<div />` representa una etiqueta div HTML pero `<Welcome />` representa un componente y requiere que `Welcome` esté definido.
 > 
 > Para saber más sobre el razonamiento detrás de esta convención, puedes consultar [JSX en profundidad](/docs/jsx-in-depth.html#user-defined-components-must-be-capitalized).
 
@@ -234,7 +234,7 @@ function Comment(props) {
 
 [](codepen://components-and-props/extracting-components-continued)
 
-Extraer componentes puede parecer un trabajo pesado al principio, pero tener una paleta de componentes reutilizables vale la pena en aplicaciones más grandes. Una buena regla en general es que si una parte de su UI se usa varias veces (`Button`, `Panel`, `Avatar`), o es lo suficientemente compleja por sí misma (`App`, `FeedStory`, `Comment`), es buen candidato para ser un componente reutilizable.
+Extraer componentes puede parecer un trabajo pesado al principio, pero tener una paleta de componentes reutilizables vale la pena en aplicaciones más grandes. Una buena regla en general es que si una parte de su interfaz de usuario se usa varias veces (`Button`, `Panel`, `Avatar`), o es lo suficientemente compleja por sí misma (`App`, `FeedStory`, `Comment`), es buen candidato para ser un componente reutilizable.
 
 ## Las props son de solo lectura {#props-are-read-only}
 
@@ -246,7 +246,7 @@ function sum(a, b) {
 }
 ```
 
-Tales funciones son llamadas ["puras"](https://en.wikipedia.org/wiki/Pure_function) por que no tratan de cambiar sus entradas, y siempre devuelven el mismo resultado para las mismas entradas.
+Tales funciones son llamadas ["puras"](https://es.wikipedia.org/wiki/Programaci%C3%B3n_funcional#Funciones_puras) por que no tratan de cambiar sus entradas, y siempre devuelven el mismo resultado para las mismas entradas.
 
 En contraste, esta función es impura por que cambia su propia entrada:
 
@@ -260,4 +260,4 @@ React es bastante flexible pero tiene una sola regla estricta:
 
 **Todos los componentes de React deben actuar como funciones puras con respecto a sus props.**
 
-Por supuesto, las UI de las aplicaciones son dinámicas y cambian con el tiempo. En la [siguiente sección](/docs/state-and-lifecycle.html), introduciremos un nuevo concepto de "estado". El estado le permite a los componentes de React cambiar su salida a lo largo del tiempo en respuesta a acciones del usuario, respuestas de red y cualquier otra cosa, sin violar esta regla.
+Por supuesto, las interfaces de usuario de las aplicaciones son dinámicas y cambian con el tiempo. En la [siguiente sección](/docs/state-and-lifecycle.html), introduciremos un nuevo concepto de "estado". El estado le permite a los componentes de React cambiar su salida a lo largo del tiempo en respuesta a acciones del usuario, respuestas de red y cualquier otra cosa, sin violar esta regla.
diff --git a/content/docs/conditional-rendering.md b/content/docs/conditional-rendering.md
index 150fb1d38..a537de44e 100644
--- a/content/docs/conditional-rendering.md
+++ b/content/docs/conditional-rendering.md
@@ -10,7 +10,7 @@ redirect_from:
 
 En React, puedes crear distintos componentes que encapsulan el comportamiento que necesitas. Entonces, puedes renderizar solamente algunos de ellos, dependiendo del estado de tu aplicación.
 
-El renderizado condicional en React funciona de la misma forma que lo hacen las condiciones en JavaScript. Usa operadores de JavaScript como [`if`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if...else) o el [operador condicional](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Operadores/Conditional_Operator) para crear elementos representando el estado actual, y deja que React actualice la UI para emparejarlos.
+El renderizado condicional en React funciona de la misma forma que lo hacen las condiciones en JavaScript. Usa operadores de JavaScript como [`if`](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Statements/if...else) o el [operador condicional](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Operadores/Conditional_Operator) para crear elementos representando el estado actual, y deja que React actualice la interfaz de usuario para emparejarlos.
 
 Considera estos dos componentes:
 
@@ -44,7 +44,7 @@ ReactDOM.render(
 
 [**Pruébalo en CodePen**](https://codepen.io/gaearon/pen/ZpVxNq?editors=0011)
 
-Este ejemplo renderiza un saludo diferente según el valor de la prop `isLoggedIn`.
+Este ejemplo renderiza un saludo diferente según el valor del prop `isLoggedIn`.
 
 ### Variables de elementos {#element-variables}
 
@@ -187,7 +187,7 @@ Al igual que en JavaScript, depende de ti elegir un estilo apropiado en base a l
 
 En casos excepcionales, es posible que desees que un componente se oculte a sí mismo aunque haya sido renderizado por otro componente. Para hacer esto, devuelve `null` en lugar del resultado de renderizado.
 
-En el siguiente ejemplo, el `<WarningBanner />` se renderiza dependiendo del valor de la prop llamada `warn`. Si el valor de la prop es `false`, entonces el componente no se renderiza:
+En el siguiente ejemplo, el `<WarningBanner />` se renderiza dependiendo del valor del prop llamado `warn`. Si el valor del prop es `false`, entonces el componente no se renderiza:
 
 ```javascript{2-4,29}
 function WarningBanner(props) {
diff --git a/content/docs/create-a-new-react-app.md b/content/docs/create-a-new-react-app.md
index 1da901ebe..37939b75d 100644
--- a/content/docs/create-a-new-react-app.md
+++ b/content/docs/create-a-new-react-app.md
@@ -33,7 +33,7 @@ El equipo de React principalmente recomienda las siguientes soluciones:
 - Si estás **aprendiendo React** o **creando una nueva [aplicación de página única](/docs/glossary.html#single-page-application),** usa [Create React App](#create-react-app).
 - Si estás construyendo un **sito web renderizado en servidor con Node.js,** prueba [Next.js](#nextjs).
 - Si estás construyendo un **sitio web orientado a contenido estático,** prueba [Gatsby](#gatsby).
-- Si estás construyendo una **biblioteca de componentes** o **integrando una base de código existente**, prueba [Cadenas de Herramientas más Flexibles](#cadenas-de-herramientas-ms-flexibles).
+- Si estás construyendo una **biblioteca de componentes** o **integrando una base de código existente**, prueba [Cadenas de Herramientas más Flexibles](#more-flexible-toolchains).
 
 ### Create React App {#create-react-app}
 
@@ -49,7 +49,7 @@ npm start
 
 >Nota
 >
->En la primera línea `npx` no es una errata: Es una [herramienta de ejecución de paquetes que viene con npm 5.2+](https://medium.com/@maybekatz/introducing-npx-an-npm-package-runner-55f7d4bd282b).
+>En la primera línea `npx` no es un error de escritura: Es una [herramienta de ejecución de paquetes que viene con npm 5.2+](https://medium.com/@maybekatz/introducing-npx-an-npm-package-runner-55f7d4bd282b).
 
 Create React App no se encarga de la lógica de `backend` o de bases de datos; tan solo crea un flujo de construcción para `frontend`, de manera que lo puedes usar con cualquier `backend`. Para ello internamente usa [Babel](http://babeljs.io/) y [webpack](https://webpack.js.org/), pero no necesitas saber nada de estas herramientas para usar Create React App.
 
@@ -77,7 +77,7 @@ Las siguientes cadenas de herramientas ofrecen más opciones y flexibilidad. Las
 
 - **[Parcel](https://parceljs.org/)** es un empaquetador de aplicaciones web rápido y de cero configuración que [funciona con React](https://parceljs.org/recipes.html#react).
 
-- **[Razzle](https://github.com/jaredpalmer/razzle)** es un marco de trabajo de renderizado en servidor que no requiere ninguna configuración, pero ofrece más flexibilidad que Next.js.
+- **[Razzle](https://github.com/jaredpalmer/razzle)** es un framework de renderizado en servidor que no requiere ninguna configuración, pero ofrece más flexibilidad que Next.js.
 
 ## Creando una cadena de herramientas desde cero {#creating-a-toolchain-from-scratch}
 
diff --git a/content/docs/forms.md b/content/docs/forms.md
index 3474e511b..0c5c73cfb 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -14,10 +14,10 @@ Los elementos de formularios en HTML funcionan un poco diferente a otros element
 ```html
 <form>
   <label>
-    Nombre:
+    Name:
     <input type="text" name="name" />
   </label>
-  <input type="submit" value="Enviar" />
+  <input type="submit" value="Submit" />
 </form>
 ```
 
@@ -46,7 +46,7 @@ class NameForm extends React.Component {
   }
 
   handleSubmit(event) {
-    alert('Un nombre fue suministrado: ' + this.state.value);
+    alert('A name was submitted: ' + this.state.value);
     event.preventDefault();
   }
 
@@ -54,10 +54,10 @@ class NameForm extends React.Component {
     return (
       <form onSubmit={this.handleSubmit}>
         <label>
-          Nombre:
+          Name:
           <input type="text" value={this.state.value} onChange={this.handleChange} />
         </label>
-        <input type="submit" value="Enviar" />
+        <input type="submit" value="Submit" />
       </form>
     );
   }
@@ -82,7 +82,7 @@ En HTML, el elemento `<textarea>` define su texto por sus hijos:
 
 ```html
 <textarea>
-  Hola, esto es un poco de texto dentro de un área de texto
+  Hello there, this is some text in a text area
 </textarea>
 ```
 
@@ -93,7 +93,7 @@ class EssayForm extends React.Component {
   constructor(props) {
     super(props);
     this.state = {
-      value: 'Por favor escribe un ensayo sobre tu elemento del DOM favorito.'
+      value: 'Please write an essay about your favorite DOM element.'
     };
 
     this.handleChange = this.handleChange.bind(this);
@@ -105,7 +105,7 @@ class EssayForm extends React.Component {
   }
 
   handleSubmit(event) {
-    alert('Un ensayo fue enviado: ' + this.state.value);
+    alert('An essay was submitted: ' + this.state.value);
     event.preventDefault();
   }
 
@@ -113,10 +113,10 @@ class EssayForm extends React.Component {
     return (
       <form onSubmit={this.handleSubmit}>
         <label>
-          Ensayo:
+          Essay:
           <textarea value={this.state.value} onChange={this.handleChange} />
         </label>
-        <input type="submit" value="Enviar" />
+        <input type="submit" value="Submit" />
       </form>
     );
   }
@@ -131,9 +131,9 @@ En HTML, `<select>` crea una lista desplegable. Por ejemplo, este HTML crea una
 
 ```html
 <select>
-  <option value="grapefruit">Toronja</option>
-  <option value="lime">Lima</option>
-  <option selected value="coconut">Coco</option>
+  <option value="grapefruit">Grapefruit</option>
+  <option value="lime">Lime</option>
+  <option selected value="coconut">Coconut</option>
   <option value="mango">Mango</option>
 </select>
 ```
@@ -155,7 +155,7 @@ class FlavorForm extends React.Component {
   }
 
   handleSubmit(event) {
-    alert('Tu sabor favorito es: ' + this.state.value);
+    alert('Your favorite flavor is: ' + this.state.value);
     event.preventDefault();
   }
 
@@ -163,15 +163,15 @@ class FlavorForm extends React.Component {
     return (
       <form onSubmit={this.handleSubmit}>
         <label>
-          Selecciona tu sabor favorito:
+          Pick your favorite flavor:
           <select value={this.state.value} onChange={this.handleChange}>
-            <option value="grapefruit">Toronja</option>
-            <option value="lime">Lima</option>
-            <option value="coconut">Coco</option>
+            <option value="grapefruit">Grapefruit</option>
+            <option value="lime">Lime</option>
+            <option value="coconut">Coconut</option>
             <option value="mango">Mango</option>
           </select>
         </label>
-        <input type="submit" value="Enviar" />
+        <input type="submit" value="Submit" />
       </form>
     );
   }
@@ -232,7 +232,7 @@ class Reservation extends React.Component {
     return (
       <form>
         <label>
-          Va a ir:
+          Is going:
           <input
             name="isGoing"
             type="checkbox"
@@ -241,7 +241,7 @@ class Reservation extends React.Component {
         </label>
         <br />
         <label>
-          Número de Invitados:
+          Number of guests:
           <input
             name="numberOfGuests"
             type="number"
diff --git a/content/docs/forwarding-refs.md b/content/docs/forwarding-refs.md
index c58e0a088..aa09e0b2e 100644
--- a/content/docs/forwarding-refs.md
+++ b/content/docs/forwarding-refs.md
@@ -71,6 +71,6 @@ Si nombras la función, _DevTools_ también incluirá su nombre (Ej: "*ForwardRe
 
 `embed:forwarding-refs/wrapped-component-with-function-name.js`
 
-Puedes incluso asigna la propiedad `displayName` de la función para que incluya el componente que estás envolviendo:
+Puedes incluso asignar la propiedad `displayName` de la función para que incluya el componente que estás envolviendo:
 
 `embed:forwarding-refs/customized-display-name.js`
diff --git a/content/docs/fragments.md b/content/docs/fragments.md
index a0c59a681..0d3af5855 100644
--- a/content/docs/fragments.md
+++ b/content/docs/fragments.md
@@ -17,7 +17,7 @@ render() {
 }
 ```
 
-También hay una nueva [sintaxis corta](#sintaxis-corta) para declararlos, pero aún no es soportada por todas las herramientas populares.
+También hay una nueva [sintaxis corta](#short-syntax) para declararlos, pero aún no es soportada por todas las herramientas populares.
 
 ## Motivación {#motivation}
 
diff --git a/content/docs/getting-started.md b/content/docs/getting-started.md
index ba10a4488..bb9ba6d17 100644
--- a/content/docs/getting-started.md
+++ b/content/docs/getting-started.md
@@ -24,11 +24,11 @@ Esta página es un resumen de la documentación de React y recursos relacionados
 
 ---
 
-- [Prueba React](#prueba-react)
-- [Aprende React](#aprende-react)
-- [Mantente Informado](#mantente-informado)
-- [Documentación por Versiones](#documentación-por-versiones)
-- [¿Algo hace falta?](#¿algo-hace-falta)
+- [Prueba React](#try-react)
+- [Aprende React](#learn-react)
+- [Mantente Informado](#staying-informed)
+- [Documentación por Versiones](#versioned-documentation)
+- [¿Algo hace falta?](#something-missing)
 
 ## Prueba React {#try-react}
 
@@ -76,7 +76,7 @@ Si vienes con experiencia como diseñador, [estos recursos](http://reactfordesig
 
 La documentación de React asume cierta familiaridad con la programación en Javascript. No necesitas ser un experto, pero es más difícil aprender React y Javascript al mismo tiempo.
 
-Recomendamos pasar por este [resumen de Javascript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/A_re-introduction_to_JavaScript) para medir tu nivel de conocimiento. Te tomará entre 30 minutos a 1 hora, pero te sentirás más seguro aprendiendo React.
+Recomendamos pasar por este [resumen de Javascript](https://developer.mozilla.org/es/docs/Web/JavaScript/A_re-introduction_to_JavaScript) para medir tu nivel de conocimiento. Te tomará entre 30 minutos a 1 hora, pero te sentirás más seguro aprendiendo React.
 
 >Consejo
 >
diff --git a/content/docs/handling-events.md b/content/docs/handling-events.md
index ca05e7c3c..6eec8aa46 100644
--- a/content/docs/handling-events.md
+++ b/content/docs/handling-events.md
@@ -93,7 +93,7 @@ ReactDOM.render(
 
 [**Pruébalo en CodePen**](http://codepen.io/gaearon/pen/xEmzGg?editors=0010)
 
-Tienes que tener mucho cuidado en cuanto al significado de `this` en los callbacks de JSX. En JavaScript, los métodos de clase no están [ligados](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_objects/Function/bind) por defecto. Si olvidas ligar `this.handleClick` y lo pasas a `onClick`, `this` sera `undefined` cuando se llame la función.
+Tienes que tener mucho cuidado en cuanto al significado de `this` en los callbacks de JSX. En JavaScript, los métodos de clase no están [ligados](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_objects/Function/bind) por defecto. Si olvidas ligar `this.handleClick` y lo pasas a `onClick`, `this` será `undefined` cuando se llame la función.
 
 Esto no es un comportamiento especifico de React; esto hace parte de [como operan las funciones JavaScript](https://www.smashingmagazine.com/2014/01/understanding-javascript-function-prototype-bind/). Generalmente, si refieres un método sin usar `()` después de este, tal como `onClick={this.handleClick}`, deberías ligar ese método.
 
@@ -101,7 +101,7 @@ Si te molesta llamar `bind`, existen dos maneras de evitarlo. Si usas la sintaxi
 
 ```js{2-6}
 class LoggingButton extends React.Component {
-  // Esta sintaxis nos asegura que `this` esta ligado dentro de handleClick
+  // Esta sintaxis nos asegura que `this` está ligado dentro de handleClick
   // Peligro: esto es una sintaxis *experimental*
   handleClick = () => {
     console.log('this is:', this);
@@ -119,7 +119,7 @@ class LoggingButton extends React.Component {
 
 Esta sintaxis está habilitada por defecto en [Create React App](https://github.com/facebookincubator/create-react-app).
 
-Si no estas usando la sintaxis de campos públicos de clases, puedes usar una [función flecha](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Functions/Arrow_functions) en el callback:
+Si no estas usando la sintaxis de campos públicos de clases, puedes usar una [función flecha](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Functions/Arrow_functions) en el callback:
 
 ```js{7-9}
 class LoggingButton extends React.Component {
diff --git a/content/docs/hello-world.md b/content/docs/hello-world.md
index 6bad0a4e9..8b433cec2 100644
--- a/content/docs/hello-world.md
+++ b/content/docs/hello-world.md
@@ -10,12 +10,12 @@ El más pequeño de los ejemplos de React se ve así:
 
 ```js
 ReactDOM.render(
-  <h1>¡Hola mundo!</h1>,
+  <h1>Hello, world!</h1>,
   document.getElementById('root')
 );
 ```
 
-Este muestra un encabezado con el texto "¡Hola mundo!" en la página.
+Este muestra un encabezado con el texto "Hello, world!" en la página.
 
 [](codepen://hello-world)
 
@@ -27,11 +27,11 @@ En esta guía, examinaremos los componentes básicos de las aplicaciones React:
 
 >Tip
 >
->Esta guía está diseñada para personas que prefieren **aprender los conceptos paso a paso**. Si tú prefieres aprender haciendo, revisa nuestro [tutorial práctico](/tutorial/tutorial.html). Encontrarás que esta guía y el tutorial se complementan el uno al otro.
+>Esta guía está diseñada para personas que prefieren **aprender los conceptos paso a paso**. Si prefieres aprender mediante práctica, revisa nuestro [tutorial práctico](/tutorial/tutorial.html). Encontrarás que esta guía y el tutorial se complementan el uno al otro.
 
 Este es el primer capítulo en una guía paso a paso sobre los principales conceptos de React. Puedes encontrar una lista de todos los capítulos en la barra de navegación lateral. Si estás leyendo esto desde un dispositivo móvil, puedes acceder a la navegación presionando el botón en la esquina inferior derecha de tu pantalla.
 
-Cada capítulo en esta guía se construye en base al conocimiento presentado en capítulos anteriores. **Tú puedes aprender la mayoría de React leyendo la guía de conceptos "Conceptos Principales" en el orden que aparecen en la barra lateral.** Por ejemplo, ["Introducción a JSX”](/docs/introducing-jsx.html) es el siguiente capítulo después de este.
+Cada capítulo en esta guía se construye en base al conocimiento presentado en capítulos anteriores. **Puedes aprender la mayoría de React leyendo la guía de conceptos "Conceptos Principales" en el orden que aparecen en la barra lateral.** Por ejemplo, ["Introducción a JSX”](/docs/introducing-jsx.html) es el siguiente capítulo después de este.
 
 ## Suposiciones del nivel de conocimiento {#knowledge-level-assumptions}
 
diff --git a/content/docs/higher-order-components.md b/content/docs/higher-order-components.md
index 17c0b3182..0be99f9ba 100644
--- a/content/docs/higher-order-components.md
+++ b/content/docs/higher-order-components.md
@@ -45,7 +45,7 @@ class CommentList extends React.Component {
   }
 
   componentWillUnmount() {
-    // Eliminar el gestor de eventos de cambios
+    // Eliminar el manejador de eventos de cambios
     DataSource.removeChangeListener(this.handleChange);
   }
 
@@ -102,9 +102,9 @@ class BlogPost extends React.Component {
 
 `CommentList` y `BlogPost` no son idénticos, ambos llaman a métodos distintos en `DataSource`, y renderizan una salida diferente. Pero gran parte de su implementación es la misma:
 
-- Al montar, añadir un gestor de eventos de cambio al `DataSource`.
-- En el gestor de eventos de cambio, llamar `setState` cada vez que la fuente de datos cambie.
-- Al desmontar, eliminar el gestor de eventos de cambio.
+- Al montar, añadir un manejador de eventos de cambio al `DataSource`.
+- En el manejador de eventos, llamar `setState` cada vez que la fuente de datos cambie.
+- Al desmontar, eliminar el manejador de eventos de cambio.
 
 Puedes imaginarte que en una aplicación grande, este mismo patrón de suscribirse a `DataSource` y llamar `setState` se repetirá una y otra vez. Necesitamos una abstracción que nos permita definir esta lógica en un solo lugar y compartirla a través de múltiples componentes. En esto es donde los componentes de orden superior se destacan.
 
@@ -211,7 +211,7 @@ function logProps(WrappedComponent) {
 }
 ```
 
-Este *HOC* posee la misma funcionalidad que la versión con mutación, pero al mismo tiempo evita el potencial de conflictos. Funciona igualmente bien com componentes de clase o de función. Y dado que es una función pura es posible componerlo con otros *HOCs*, o incluso consigo mismo.
+Este *HOC* posee la misma funcionalidad que la versión con mutación, pero al mismo tiempo evita el potencial de conflictos. Funciona igualmente bien con componentes de clase o de función. Y dado que es una función pura es posible componerlo con otros *HOCs*, o incluso consigo mismo.
 
 Puedes haber notado similitud entre los *HOCs* y un patrón llamado **componentes contenedores**. Los componentes contenedores son parte de una estrategia de separación de responsabilidades entre preocupaciones de alto y bajo nivel. Los contenedores manejan temas como subscripciones y estado, y pasan *props* a componentes que manejan temas como renderizar la interfaz de usuario. Los *HOCs* usan contenedores como parte de su implementación. Puedes pensar en los *HOCs* como definiciones de componentes contenedores parametrizables. 
 
@@ -282,7 +282,7 @@ Esta forma puede parecer confusa o innecesaria, pero tiene una propiedad útil.
 const EnhancedComponent = withRouter(connect(commentSelector)(WrappedComponent))
 
 // ... puedes usar una utilidad para componer funciones
-// compose(f, g, h) is the same as (...args) => f(g(h(...args)))
+// compose(f, g, h) es lo mismo que (...args) => f(g(h(...args)))
 const enhance = compose(
   // Ambos son HOCs que reciben un único argumento
   withRouter,
diff --git a/content/docs/introducing-jsx.md b/content/docs/introducing-jsx.md
index 1cdd68630..44d54d888 100644
--- a/content/docs/introducing-jsx.md
+++ b/content/docs/introducing-jsx.md
@@ -103,9 +103,9 @@ const element = <img src={user.avatarUrl}></img>;
 
 No pongas comillas rodeando llaves cuando insertes una expresión JavaScript en un atributo. Debes utilizar comillas (para los valores de los strings) o llaves (para las expresiones), pero no ambas en el mismo atributo.
 
->**Warning:**
+>**Advertencia:**
 >
->Dado que JSX está más cercano a JavaScript que a HTML, React DOM usa la convención de nomenclatura `camelCase` en vez de nombres de atributos HTML.
+>Dado que JSX es más cercano a JavaScript que a HTML, React DOM usa la convención de nomenclatura `camelCase` en vez de nombres de atributos HTML.
 >
 >Por ejemplo, `class` se vuelve [`className`](https://developer.mozilla.org/es/docs/Web/API/Element/className) en JSX, y `tabindex` se vuelve [`tabIndex`](https://developer.mozilla.org/es/docs/Web/API/HTMLElement/tabIndex).
 
@@ -142,9 +142,9 @@ Por defecto, React DOM [escapa](http://stackoverflow.com/questions/7381974/which
 
 ### JSX representa objetos {#jsx-represents-objects}
 
-Babel compila JSX bajo llamados a `React.createElement()`.
+Babel compila JSX a llamadas de `React.createElement()`.
 
-Estos dos ejemplos son identicos:
+Estos dos ejemplos son idénticos:
 
 ```js
 const element = (
diff --git a/content/docs/jsx-in-depth.md b/content/docs/jsx-in-depth.md
index 461e40cf8..92b4092e0 100644
--- a/content/docs/jsx-in-depth.md
+++ b/content/docs/jsx-in-depth.md
@@ -57,7 +57,7 @@ Los tipos en mayúsculas indican que la etiqueta JSX se refiere a un componente
 
 ### React debe estar al alcance {#react-must-be-in-scope}
 
-Como JSX se compila en llamadas a `React.createElement`, la biblioteca` React` también debe estar siempre dentro del alcance de su código JSX.
+Como JSX se compila en llamadas a `React.createElement`, la biblioteca` React` también debe estar siempre dentro del alcance de tu código JSX.
 
 Por ejemplo, ambas importaciones son necesarias en este código, a pesar de que `React` y `CustomButton` no están directamente referenciados desde JavaScript:
 
@@ -228,7 +228,7 @@ Si no pasas ningún valor para un prop, el valor predeterminado es `true`. Estas
 <MyTextBox autocomplete={true} />
 ```
 
-En general, no recomendamos usarlo porque puede confundirse con la [notación simplificada de objetos ES6](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Object_initializer#New_notations_in_ECMAScript_2015) `{foo}` que es la abreviatura de `{foo: foo}` en lugar de `{foo: true}`. Este comportamiento está para que coincida con el de HTML.
+En general, no recomendamos usarlo porque puede confundirse con la [notación simplificada de objetos ES6](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Operators/Object_initializer#New_notations_in_ECMAScript_2015) `{foo}` que es la abreviatura de `{foo: foo}` en lugar de `{foo: true}`. Este comportamiento está para que coincida con el de HTML.
 
 ### Atributos de propagación {#spread-attributes}
 
@@ -282,7 +282,7 @@ Puede poner un *string* entre las etiquetas de apertura y cierre y `props.childr
 <MyComponent>Hello world!</MyComponent>
 ```
 
-Esto es JSX válido, y `props.children` en` MyComponent` simplemente será el *string* `Hello world!`. El código HTML no se ha escapado, por lo que generalmente puedes escribir JSX de la misma manera que escribirías HTML de esta manera:
+Esto es JSX válido, y `props.children` en `MyComponent` simplemente será el *string* `Hello world!`. El código HTML no se ha escapado, por lo que generalmente puedes escribir JSX de la misma manera que escribirías HTML de esta manera:
 
 ```html
 <div>This is valid HTML &amp; JSX at the same time.</div>
@@ -331,7 +331,7 @@ Puedes mezclar diferentes tipos de hijos, así que puedes usar literales de *str
 </div>
 ```
 
-A React component can also return an array of elements:
+Un componente de React también puede retornar un array de elementos:
 
 ```js
 render() {
@@ -452,7 +452,7 @@ Para solucionar esto, asegúrate de que la expresión antes de `&&` sea siempre
 </div>
 ```
 
-Por el contrario, si desea que aparezca un valor como `false`, `true`, `null` o `undefined` en la salida, debes primero [convertirlo en una cadena](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#String_conversion):
+Por el contrario, si desea que aparezca un valor como `false`, `true`, `null` o `undefined` en la salida, debes primero [convertirlo en una cadena](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/String#String_conversion):
 
 ```js{2}
 <div>
diff --git a/content/docs/lifting-state-up.md b/content/docs/lifting-state-up.md
index b2504637c..ba0333955 100644
--- a/content/docs/lifting-state-up.md
+++ b/content/docs/lifting-state-up.md
@@ -308,9 +308,9 @@ Recapitulemos qué pasa cuando editamos una entrada:
 * React llama a la función especificada como `onChange` en el `<input>` del DOM. En nuestro caso es el método `handleChange` en el componente `TemperatureInput`.
 * El método `handleChange` en el componente `TemperatureInput` llama a `this.props.onTemperatureChange()` con el nuevo valor. Sus propiedades, incluyendo `onTemperatureChange`, fueron provistas para el componente padre `Calculator`.
 * Cuando renderizó previamente, `Calculator` especificó que `onTemperatureChange` del componente `TemperatureInput` con la escala Celsius es el método `handleCelsiusChange` y `onTemperatureChange` del componente `TemperatureUnit` con escala Fahrenheit es el método `handleFahrenheitChange`. Entonces, cada uno de estos métodos es llamado dependiendo del componente que se edite.
-* Dentro de estos métodos, el componente `Calculator` pregunta a React para rerenderizarse a sí mismo llamando al método `this.setState()` con el nuevo valor y la escala actual de la entrada que acabamos de editar.
-* React llama al método `render` del componente `Calculator` para saber cómo debe lucir la IU. Los valores de ambas entradas son recalculados en base a la temperatura actual y la escala activa. La conversión de temperatura es hecha aquí.
-* React llama a los métodos `render` de los componentes `TemperatureInput` de manera individual con sus nuevas propiedades especificadas por `Calculator`. Aprende como sus IU deberían verse.
+* Dentro de estos métodos, el componente `Calculator` pregunta a React para volver a renderizar a sí mismo llamando al método `this.setState()` con el nuevo valor y la escala actual de la entrada que acabamos de editar.
+* React llama al método `render` del componente `Calculator` para saber cómo debe lucir la interfaz de usuario. Los valores de ambas entradas son recalculados en base a la temperatura actual y la escala activa. La conversión de temperatura es hecha aquí.
+* React llama a los métodos `render` de los componentes `TemperatureInput` de manera individual con sus nuevas propiedades especificadas por `Calculator`. Aprende como sus interfaces de usuario deberían verse.
 * React llama al método `render` del componente `BoilingVerdict`, pasando la temperatura en Celsius como una propiedad.
 * React DOM actualiza el DOM con el componente `BolingVerdict` y sincroniza los valores deseados para las entradas. La entrada que acabmos de actualizar recibe su valor actual, y la otra entrada es actualizada a su temperatura luego de hacer la conversión.
 
@@ -324,6 +324,6 @@ Levantar el estado implica escribir más código *"boilerplate"* que los enfoque
 
 Si algo puede ser derivado de las propiedades o el estado, probablemente no debería estar en el estado. Por ejemplo, en vez de almacenar `celsiusValue` y `fahrenheitValue`, solamente almacenamos la última edición a `temperature` y `scale`. El valor de de la otra entrada siempre puede ser calculado desde el método `render()`. Esto nos permite limpiar o aplicar un redondeo a la otra entrada sin perder la precisión en la entrada del usuario.
 
-Cuando veas que algo está mal en la IU, puedes usar [React Developer Tools](https://github.com/facebook/react-devtools) para inspeccionar las propiedades y moverte hacia arriba en el árbol hasta encontrar el componente responsable de actualizar el estado. Esto te permite seguir un error hasta su fuente:
+Cuando veas que algo está mal en la interfaz de usuario, puedes usar [React Developer Tools](https://github.com/facebook/react-devtools) para inspeccionar las propiedades y moverte hacia arriba en el árbol hasta encontrar el componente responsable de actualizar el estado. Esto te permite seguir un error hasta su fuente:
 
 <img src="../images/docs/react-devtools-state.gif" alt="Monitoring State in React DevTools" max-width="100%" height="100%">
diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index 46377a991..3200aafab 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -42,11 +42,11 @@ ReactDOM.render(
 );
 ```
 
-[**Pruebalo en CodePen**](https://codepen.io/gaearon/pen/GjPyQr?editors=0011)
+[**Pruébalo en CodePen**](https://codepen.io/gaearon/pen/GjPyQr?editors=0011)
 
 Este código muestra una lista de números entre 1 y 5.
 
-### Componente Básico de Lista {#basic-list-component}
+### Componente básico de lista {#basic-list-component}
 
 Usualmente renderizarías listas dentro de un [componente](/docs/components-and-props.html).
 
@@ -298,4 +298,4 @@ function NumberList(props) {
 
 [**Pruébalo en CodePen**](https://codepen.io/gaearon/pen/BLvYrB?editors=0010)
 
-Algunas veces esto resulta en código mas claro, pero este estilo también puede ser abusado. Como en JavaScript, depende de ti decidir cuando vale la pena extraer una variable por legibilidad. Ten en mente que si el cuerpo de `map()` esta muy anidado, puede ser un buen momento para [extraer un componente](/docs/components-and-props.html#extracting-components).
+Algunas veces esto resulta más claro en código, pero este estilo también puede ser abusado. Como en JavaScript, depende de ti decidir cuando vale la pena extraer una variable por legibilidad. Ten en mente que si el cuerpo de `map()` está muy anidado, puede ser un buen momento para [extraer un componente](/docs/components-and-props.html#extracting-components).
diff --git a/content/docs/portals.md b/content/docs/portals.md
index 43ae18c0b..00c14d8a3 100644
--- a/content/docs/portals.md
+++ b/content/docs/portals.md
@@ -4,7 +4,7 @@ title: Portales
 permalink: docs/portals.html
 ---
 
-Los portales proporcionan una opción de primera clase para renderizar hijos en un nodo DOM que existe por fuera de la jerarquía del DOM del Componente padre.
+Los portales proporcionan una opción de primera clase para renderizar hijos en un nodo DOM que existe por fuera de la jerarquía del DOM del componente padre.
 
 ```js
 ReactDOM.createPortal(child, container)
diff --git a/content/docs/react-without-es6.md b/content/docs/react-without-es6.md
index cd1b60c28..68fec2eee 100644
--- a/content/docs/react-without-es6.md
+++ b/content/docs/react-without-es6.md
@@ -100,7 +100,7 @@ class SayHello extends React.Component {
   }
 
   render() {
-    // Porque `this.handleClick` está vinculada, podemos utilizarla como un *event handler*
+    // Porque `this.handleClick` está vinculada, podemos utilizarla como un manejador de evento
     return (
       <button onClick={this.handleClick}>
         Say hello
@@ -132,7 +132,7 @@ var SayHello = createReactClass({
 });
 ```
 
-Esto significa que las clases de ES6 traen consigo la necesidad de escribir un poco más de código repetitivo para utilizar *event handlers*, pero la ventaja radica en una ligera mejora del rendimiento en aplicaciones grandes.
+Esto significa que las clases de ES6 traen consigo la necesidad de escribir un poco más de código repetitivo para utilizar *manejadores de eventos*, pero la ventaja radica en una ligera mejora del rendimiento en aplicaciones grandes.
 
 Si el código repetitivo no es atractivo para ti, puedes activar la propuesta de sintaxis **experimental** [Propiedades de Clases](https://babeljs.io/docs/plugins/transform-class-properties/) con Babel:
 
diff --git a/content/docs/reconciliation.md b/content/docs/reconciliation.md
index da2ed3534..aa9e8b654 100644
--- a/content/docs/reconciliation.md
+++ b/content/docs/reconciliation.md
@@ -136,9 +136,9 @@ En la práctica, encontrar una clave no suele ser difícil. Es posible que el el
 <li key={item.id}>{item.name}</li>
 ```
 
-Cuando ese no sea el caso, puede agregar una nueva propiedad de ID a su modelo o marcar algunas partes del contenido para generar una clave. La clave solo tiene que ser única entre sus hermanos, no globalmente única.
+Cuando ese no sea el caso, puedes agregar una nueva propiedad de ID a su modelo o marcar algunas partes del contenido para generar una clave. La clave solo tiene que ser única entre sus hermanos, no globalmente única.
 
-Como último recurso, puede pasar el índice de un elemento en la matriz como una clave. Esto puede funcionar bien si los ítems nunca se reordenan, pero los reordenamientos serán lentos.
+Como último recurso, puedes pasar el índice de un elemento en la matriz como una clave. Esto puede funcionar bien si los ítems nunca se reordenan, pero los reordenamientos serán lentos.
 
 Reorganizar también puede causar problemas de estado del componente cuando los índices se utilizan como claves. Si la clave es un índice, mover un elemento lo cambia. Como resultado, el estado el componente para cosas como entradas no controladas pueden mezclarse y actualizarse de manera inesperada.
 
diff --git a/content/docs/reference-dom-elements.md b/content/docs/reference-dom-elements.md
index 0ae60ad1a..c2f24f657 100644
--- a/content/docs/reference-dom-elements.md
+++ b/content/docs/reference-dom-elements.md
@@ -63,7 +63,7 @@ El atributo `selected` es compatible con los componentes tipo `<option>`. Puedes
 
 >Nota
 >
->Algunos ejemplos en la documentación usan el atributo `style` por conveniencia, pero **generalmente no se recomienda usar el atributo `style` como medio principal para estilizar elementos**. En la mayoría de los casos, [`className`](#classname) debe ser usado para hacer referencia a clases definidas en documentos CSS externos. En React, el atributo `style` se usa con mayor frecuencia para añadir estilos calculados dinámicamente al momento de renderización. Revisa tambièn [FAQ: Styling and CSS](/docs/faq-styling.html).
+>Algunos ejemplos en la documentación usan el atributo `style` por conveniencia, pero **generalmente no se recomienda usar el atributo `style` como medio principal para estilizar elementos**. En la mayoría de los casos, [`className`](#classname) debe ser usado para hacer referencia a clases definidas en documentos CSS externos. En React, el atributo `style` se usa con mayor frecuencia para añadir estilos calculados dinámicamente al momento de renderización. Revisa también [Preguntas Frecuentes: Estilo y CSS](/docs/faq-styling.html).
 
 El atributo `style` acepta un objeto de Javascript con propiedades escritas en formato *camelCase*, en lugar de un *string* CSS. Esto es consistente con la propiedad DOM `style` en Javascript, es más eficiente y previene vulnerabilidades XSS. Por ejemplo:
 
diff --git a/content/docs/reference-events.md b/content/docs/reference-events.md
index f3d77eb27..85fc55538 100644
--- a/content/docs/reference-events.md
+++ b/content/docs/reference-events.md
@@ -6,7 +6,7 @@ layout: docs
 category: Reference
 ---
 
-Esta guía de referencia documenta el contenedor `SyntheticEvent` que forma parte del sistema de eventos de React. Consulte la guía [Eventos de manipulación](/docs/handling-events.html) para obtener más información.
+Esta guía de referencia documenta el contenedor `SyntheticEvent` que forma parte del sistema de eventos de React. Consulte la guía [Manejando eventos](/docs/handling-events.html) para obtener más información.
 
 ## Resumen {#overview}
 
@@ -246,7 +246,7 @@ boolean isPrimary
 
 Una nota sobre la compatibilidad con varios navegadores:
 
-Los eventos de puntero aún no son compatibles con todos los navegadores (en el momento de escritura de este artículo, los navegadores compatibles incluyen: Chrome, Firefox, Edge e Internet Explorer). React deliberada no admite polyfill para otros navegadores, ya que un polyfill de conformidad estándar aumentaría significativamente el tamaño del paquete de `react-dom`.
+Los eventos de puntero aún no son compatibles con todos los navegadores (en el momento de escritura de este artículo, los navegadores compatibles incluyen: Chrome, Firefox, Edge e Internet Explorer). React no admite *polyfills* deliberadamente para otros navegadores, ya que un *polyfill* de conformidad estándar aumentaría significativamente el tamaño del paquete de `react-dom`.
 
 Si su aplicación requiere eventos de puntero, le recomendamos que agregue un polyfill de evento de puntero de terceros.
 
diff --git a/content/docs/reference-glossary.md b/content/docs/reference-glossary.md
index 13f795ad0..25a435ea7 100644
--- a/content/docs/reference-glossary.md
+++ b/content/docs/reference-glossary.md
@@ -11,7 +11,7 @@ permalink: docs/glossary.html
 
 Una aplicación de página única (single-page application) es una aplicación que carga una única página HTML y todos los componentes necesarios (tales como JavaScript y CSS) para que se ejecute la aplicación. Cualquier interacción con la página o páginas subsecuentes no requiere hacer solicitudes al servidor lo que significa que la página no es recargada.
 
-Aunque puedes construir una aplicación de página única en React, esto no es un requerimiento. React también puede ser utilizado para mejorar pequeñas partes de sitios web existentes con interactividad adicional. El código escrito en React puede coexistir pacíficamente con páginas renderizadas de lado del servidor por lenguajes como PHP, ó cualquier otra biblioteca del lado del cliente. De hecho, así es como React está siendo utilizado en Facebook.
+Aunque puedes construir una aplicación de página única con React, esto no es un requerimiento. React también puede ser utilizado para mejorar pequeñas partes de sitios web existentes con interactividad adicional. El código escrito en React puede coexistir pacíficamente con páginas renderizadas de lado del servidor por lenguajes como PHP, ó cualquier otra biblioteca del lado del cliente. De hecho, así es como React está siendo utilizado en Facebook.
 
 ## ES6, ES2015, ES2016, etc {#es6-es2015-es2016-etc}
 
@@ -31,11 +31,11 @@ Los *package managers* son herramientas que te permiten administrar las dependen
 
 ## CDN {#cdn}
 
-CDN son las siglas de *Content Delivery Network* (Red de Entrega de Contenido). Los *CDN* entregan contenido estático en caché desde una red de servidores alrededor del mundo.
+CDN son las siglas en inglés de *Content Delivery Network* (Red de Entrega de Contenido). Los *CDN* entregan contenido estático en caché desde una red de servidores alrededor del mundo.
 
 ## JSX {#jsx}
 
-JSX es una extensión de sintaxis para JavaScript. Es similar a un *template language*, pero tiene todo el poder de JavaScript. JSX es compilado a llamadas `React.createElement()` que regresan simples objetos de JavaScript llamados *"React elements"*. Puedes encontrar una introducción básica a JSX en la documentación [aquí](/docs/introducing-jsx.html) y un tutorial más completo de JSX [aquí](/docs/jsx-in-depth.html).
+JSX es una extensión de sintaxis para JavaScript. Es similar a un *template language*, pero tiene todo el poder de JavaScript. JSX es compilado a llamadas `React.createElement()` que regresan simples objetos de JavaScript llamados *"elementos de React"*. Puedes encontrar una introducción básica a JSX en la documentación [aquí](/docs/introducing-jsx.html) y un tutorial más completo de JSX [aquí](/docs/jsx-in-depth.html).
 
 *React DOM* usa una convención de nombres en *camelCase* para las propiedades en lugar de nombres de atributos HTML. Por ejemplo, `tabindex` se vuelve `tabIndex` en JSX. El atributo `class` se escribe como `className` ya que `class` es una palabra reservada en JavaScript:
 
@@ -76,7 +76,7 @@ class Welcome extends React.Component {
 }
 ```
 
-Los componentes pueden ser divididos en distintas piezas de funcionalidad y usados en otros componentes. Los componentes pueden regresar otros componentes, arreglos, cadenas de texto y números. Una buena regla es que si una parte de tu interfaz es usada varias veces (Botón, Panel, Avatar), o es lo suficientemente compleja (App, Noticias, Comentario), es un buen candidato para ser un componente reusable. Los nombres de los componentes deberían también comenzar con una letra mayúscula (`<Wrapper/>` **not** `<wrapper/>`). Consulte [esta documentación](/docs/components-and-props.html#rendering-a-component) para obtener más información sobre el renderizado de componentes.
+Los componentes pueden ser divididos en distintas piezas de funcionalidad y usados en otros componentes. Los componentes pueden regresar otros componentes, arreglos, cadenas de texto y números. Una buena regla es que si una parte de tu interfaz es usada varias veces (Botón, Panel, Avatar), o es lo suficientemente compleja (App, Noticias, Comentario), es un buen candidato para ser un componente reusable. Los nombres de los componentes deberían también comenzar con una letra mayúscula (`<Wrapper/>` **no** `<wrapper/>`). Consulta [esta documentación](/docs/components-and-props.html#rendering-a-component) para obtener más información sobre el renderizado de componentes.
 
 ### [`props`](/docs/components-and-props.html) {#props}
 
@@ -146,7 +146,7 @@ Las *keys* sólo tienen que ser únicas entre elementos hermanos en el mismo arr
 
 No pases algo como `Math.random()` a las *keys*. Es importante que las *keys* tengan una "indentidad estable" a través de múltiples renderizados así React puede determinar cuales elementos fueron agregados, removidos o re-ordenados. Idealmente, las *keys* deberían corresponder a un identificador único y estable que venga desde los datos, por ejemplo: `post.id`.
 
-## [Refs](/docs/refs-and-the-dom.html) {#refs}
+## [Referencias](/docs/refs-and-the-dom.html) {#refs}
 
 React admite un atributo especial que se puede agregar a cualquier componente. El atributo `ref` puede ser un objeto creado por [la función `React.createRef()`](/docs/react-api.html#reactcreateref) o una función *callback*, o una cadena de texto (en la API antigua). Cuando el atributo `ref` es una función de *callback*, la función recibe el elemento *DOM* subyacente o la instancia de clase (dependiendo del tipo de elemento) como argumento. Esto permite tener acceso directo al *DOM* del elemento o a la instancia del componente.
 
diff --git a/content/docs/reference-javascript-environment-requirements.md b/content/docs/reference-javascript-environment-requirements.md
index 209de0fd9..9ff3bd7ba 100644
--- a/content/docs/reference-javascript-environment-requirements.md
+++ b/content/docs/reference-javascript-environment-requirements.md
@@ -6,9 +6,9 @@ category: Reference
 permalink: docs/javascript-environment-requirements.html
 ---
 
-React 16 depende de tipos de colección [Map](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Map) y [Set](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Set). Si soportas navegadores y dispositivos más antiguos que aún no los proporcionan de forma nativa (por ejemplo, IE <11) o que tienen implementaciones no compatibles (por ejemplo, IE 11), considera la posibilidad de incluir un *polyfill* global en tu aplicación empaquetada, como [core-js](https://github.com/zloirock/core-js) o [babel-polyfill](https://babeljs.io/docs/usage/polyfill/).
+React 16 depende de tipos de colección [Map](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Map) y [Set](https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Set). Si aceptas navegadores y dispositivos más antiguos que aún no los proporcionan de forma nativa (por ejemplo, IE <11) o que tienen implementaciones no compatibles (por ejemplo, IE 11), considera la posibilidad de incluir un *polyfill* global en tu aplicación empaquetada, como [core-js](https://github.com/zloirock/core-js) o [babel-polyfill](https://babeljs.io/docs/usage/polyfill/).
 
-Un entorno con *polyfill* para React 16 que usa core-js para soportar navegadores más antiguos podría verse de la siguiente forma:
+Un entorno con *polyfill* para React 16 que usa core-js para aceptar navegadores más antiguos podría verse de la siguiente forma:
 
 ```js
 import 'core-js/es6/map';
diff --git a/content/docs/reference-react-component.md b/content/docs/reference-react-component.md
index f9f254090..273d3c58c 100644
--- a/content/docs/reference-react-component.md
+++ b/content/docs/reference-react-component.md
@@ -57,7 +57,7 @@ Estos métodos se llaman cuando se crea una instancia de un componente y se inse
 
 #### Actualización {#updating}
 
-Una actualización puede ser causada por cambios en los props o el state. Estos métodos se llaman en el siguiente orden cuando un componente se re renderiza:
+Una actualización puede ser causada por cambios en los props o el estado. Estos métodos se llaman en el siguiente orden cuando un componente se vuelve a renderizar:
 
 - [`static getDerivedStateFromProps()`](#static-getderivedstatefromprops)
 - [`shouldComponentUpdate()`](#shouldcomponentupdate)
@@ -100,7 +100,7 @@ Cada componente también proporciona algunas otras APIs:
 ### Propiedades de instancia {#instance-properties}
 
 - [`props`](#props)
-- [`state`](#state)
+- [`estado`](#state)
 
 * * *
 
@@ -121,9 +121,9 @@ El método `render()` es el único método requerido en un componente de clase.
 Cuando se llama, debe examinar a `this.props` y `this.state` y devolver uno de los siguientes tipos:
 
 - **Elementos de React.** normalmente creados a través de [JSX](/docs/introducing-jsx.html). Por ejemplo, `<div />` y `<MyComponent />` son elementos de React que enseñan a React a renderizar un nodo DOM, u otro componente definido por el usuario, respectivamente.
-- **Arrays y fragmentos.** Permiten que puedas devolver múltiples elementos desde el render. Consulta la documentación sobre [fragmentos](/docs/controllers) para más detalles.
-- **Portales**. Te permiten renderizar hijos en otro subárbol del DOM. Consulta la documentación sobre [subárboles](/docs/controllers) para más detalles.
-- **String and numbers.** Estos son renderizados como nodos de texto en el DOM.
+- **Arrays y fragmentos.** Permiten que puedas devolver múltiples elementos desde el render. Consulta la documentación sobre [fragmentos](/docs/fragments) para más detalles.
+- **Portales**. Te permiten renderizar hijos en otro subárbol del DOM. Consulta la documentación sobre [portales](/docs/portals) para más detalles.
+- **String y números.** Estos son renderizados como nodos de texto en el DOM.
 - **Booleanos o `nulos`**. No renderizan nada. (Principalmente existe para admitir el patrón `return test && <Child />`, donde `test` es booleano.)
 
 La función `render ()` debe ser pura, lo que significa que no modifica el estado del componente, devuelve el mismo resultado cada vez que se invoca y no interactúa directamente con el navegador.
@@ -148,11 +148,11 @@ El constructor para un componente React es llamado antes de ser montado. Al impl
 
 Normalmente, los constructores de React sólo se utilizan para dos propósitos:
 
-* Para inicializar un state local asignando un objeto al `this.state`.
+* Para inicializar un estado local asignando un objeto al `this.state`.
 
-* Para enlazar [ gestores de eventos ](/docs/handling-events.html) a una instancia.
+* Para enlazar [ manejadores de eventos ](/docs/handling-events.html) a una instancia.
 
-**No debes llamar `setState()`** en el constructor `()`. En su lugar, si su componente necesita usar el state local, ** asigna directamente el state inicial al ` this.state `** directamente en el constructor:
+**No debes llamar `setState()`** en el `constructor()`. En su lugar, si su componente necesita usar el estado local, **asigna directamente el estado inicial al `this.state`** directamente en el constructor:
 
 ```js
 constructor(props) {
@@ -169,7 +169,7 @@ Evita introducir cualquier efecto secundario o suscripciones en el constructor.
 
 > Nota
 >
-> **Evita copiar los props en el state! Es un error muy común:**
+> **¡Evita copiar los props en el estado! Es un error muy común:**
 >
 >```js
 >constructor(props) {
@@ -179,11 +179,11 @@ Evita introducir cualquier efecto secundario o suscripciones en el constructor.
 >}
 >```
 >
-> El problema es que es innecesario (puedes usar `this.props.color` directamente en su lugar), esto crea errores (actualizaciones al prop `color` no se reflejarán en el state).
+> El problema es que es innecesario (puedes usar `this.props.color` directamente en su lugar), esto crea errores (actualizaciones al prop `color` no se reflejarán en el estado).
 >
-> **Sólo utiliza este patrón si deseas ignorar intencionalmente las actualizaciones de prop.** En ese caso, tiene sentido renombrar el prop a `initialColor` o `defaultColor`. Puedes forzar al componente a "limpiar" su state interno [ cambiando su `key`](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-uncontrolled-component-with-a-key) cuando sea necesario.
+> **Sólo utiliza este patrón si deseas ignorar intencionalmente las actualizaciones de prop.** En ese caso, tiene sentido renombrar el prop a `initialColor` o `defaultColor`. Puedes forzar al componente a "limpiar" su estado interno [cambiando su `key`](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-uncontrolled-component-with-a-key) cuando sea necesario.
 >
-> Lee nuestro [post en el blog sobre como evitar states derivados](/blog/2018/06/07/you-probably-dont-need-derived-state.html) para aprender qué hacer si crees que necesitas algún state que dependa de los props.
+> Lee nuestro [post en el blog sobre como evitar estados derivados](/blog/2018/06/07/you-probably-dont-need-derived-state.html) para aprender qué hacer si crees que necesitas algún estado que dependa de los props.
 
 * * *
 
@@ -197,7 +197,7 @@ componentDidMount()
 
 Este método es un buen lugar para establecer cualquier suscripción. Si lo haces, no olvides darle de baja en `componentWillUnmount()`.
 
-**Puedes llamar `setState()` inmediatamente** en `componentDidMount()`. Se activará un renderizado extra, pero sucederá antes de que el navegador actualice la pantalla. Esto garantiza que, aunque en este caso se invocará dos veces el `render()`, el usuario no verá el estado intermedio. Utiliza este patrón con precaución porque a menudo causa problemas de rendimiento. En la mayoría de los casos, deberías ser capaz de asignar el state inicial en el constructor `()` en su lugar. Sin embargo, puede ser necesario para casos como modales y tooltips cuando se necesita medir un nodo DOM antes de representar algo que depende de su tamaño o posición.
+**Puedes llamar `setState()` inmediatamente** en `componentDidMount()`. Se activará un renderizado extra, pero sucederá antes de que el navegador actualice la pantalla. Esto garantiza que, aunque en este caso se invocará dos veces el `render()`, el usuario no verá el estado intermedio. Utiliza este patrón con precaución porque a menudo causa problemas de rendimiento. En la mayoría de los casos, deberías ser capaz de asignar el estado inicial en el `constructor()` en su lugar. Sin embargo, puede ser necesario para casos como modales y tooltips cuando se necesita medir un nodo DOM antes de representar algo que depende de su tamaño o posición.
 
 * * *
 
@@ -220,7 +220,7 @@ componentDidUpdate(prevProps) {
 }
 ```
 
-**Puedes llamar `setState()` inmediatamente** en `componentDidUpdate()` pero ten en cuenta que **debe ser envuelto en una condición** como en el ejemplo anterior, o causará un bucle infinito. También causaría una re renderización adicional que, aunque no sea visible para el usuario, puede afectar el rendimiento del componente. Si estás intentando crear un "espejo" desde un state a un prop que viene desde arriba, considera usar el prop directamente en su lugar. Lee más sobre [por qué copiar props en el state causa errores](/blog/2018/06/07/you-probably-dont-need-derived-state.html).
+**Puedes llamar `setState()` inmediatamente** en `componentDidUpdate()` pero ten en cuenta que **debe ser envuelto en una condición** como en el ejemplo anterior, o causará un bucle infinito. También causaría una renderización adicional que, aunque no sea visible para el usuario, puede afectar el rendimiento del componente. Si estás intentando crear un "espejo" desde un estado a un prop que viene desde arriba, considera usar el prop directamente en su lugar. Lee más sobre [por qué copiar props en el estado causa errores](/blog/2018/06/07/you-probably-dont-need-derived-state.html).
 
 Si tu componente implementa el ciclo de vida `getSnapshotBeforeUpdate()`(que es raro), el valor que devuelve se pasará como un tercer parámetro "snapshot" a `componentDidUpdate()`. De lo contrario, este parámetro será indefinido.
 
@@ -238,7 +238,7 @@ componentWillUnmount()
 
 `componentWillUnmount()` se invoca inmediatamente antes de desmontar y destruir un componente. Realiza las tareas de limpieza necesarias en este método, como la invalidación de temporizadores, la cancelación de solicitudes de red o la eliminación de las suscripciones que se crearon en `componentDidMount()`.
 
-**No debes llamar `setState()`** en `componentWillUnmount()` porque el componente nunca será re renderizado. Una vez que una instancia de componente sea desmontada, nunca será montada de nuevo.
+**No debes llamar `setState()`** en `componentWillUnmount()` porque el componente nunca será vuelto a renderizar. Una vez que una instancia de componente sea desmontada, nunca será montada de nuevo.
 
 * * *
 
@@ -256,9 +256,9 @@ Usa `shouldComponentUpdate()` para avisar a React si la salida de un componente
 
 `shouldComponentUpdate()` es invocado antes de renderizar cuando los nuevos accesorios o el estado están siendo recibidos. Por defecto es `true`. Este método no es llamado para el renderizado inicial o cuando `forceUpdate()` es usado.
 
-Este método sólo existe como **[optimización de rendimiento](/docs/optimizing-performance.html).** No confíes en él para "prevenir" un renderizado, ya que esto puede conducir a errores. **Considere usar el componente integrado [`PureComponent`](/docs/react-api.html#reactpurecomponent)** en lugar de escribir `shouldComponentUpdate()` a mano. `PureComponent` realiza una comparación superficial de props y state, y reduce la posibilidad de saltar una actualización necesaria.
+Este método sólo existe como **[optimización de rendimiento](/docs/optimizing-performance.html).** No confíes en él para "prevenir" un renderizado, ya que esto puede conducir a errores. **Considere usar el componente integrado [`PureComponent`](/docs/react-api.html#reactpurecomponent)** en lugar de escribir `shouldComponentUpdate()` a mano. `PureComponent` realiza una comparación superficial de props y estado, y reduce la posibilidad de saltar una actualización necesaria.
 
-Si estás seguro de querer escribirlo a mano, puedes comparar `this.props` con `nextProps` y `this.state` con `nextState` y devolver `false` para indicar a React que se puede omitir la actualización. Devolver `false` no previene a los componentes hijos de re-renderizarse cuando *su* state cambia.
+Si estás seguro de querer escribirlo a mano, puedes comparar `this.props` con `nextProps` y `this.state` con `nextState` y devolver `false` para indicar a React que se puede omitir la actualización. Devolver `false` no previene a los componentes hijos de volverse a renderizar cuando *su* estado cambia.
 
 No recomendamos realizar comprobaciones de igualdad profundas ni utilizar `JSON.stringify()` en `shouldComponentUpdate()`. Es muy ineficiente y dañará el rendimiento.
 
@@ -272,7 +272,7 @@ Actualmente, si `shouldComponentUpdate()` devuelve `false`, entonces [`component
 static getDerivedStateFromProps(props, state)
 ```
 
-`getDerivedStateFromProps` se invoca justo antes de llamar al método de render, tanto en la montura inicial como en las actualizaciones posteriores. Debes devolver un objeto para actualizar el state, o nulo para actualizar nada.
+`getDerivedStateFromProps` se invoca justo antes de llamar al método de render, tanto en la montura inicial como en las actualizaciones posteriores. Debes devolver un objeto para actualizar el estado, o nulo para actualizar nada.
 
 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) donde el estado depende de los cambios en props con el tiempo. Por ejemplo, puede ser util para implementar un componente `<Transition>` que compare su anterior hijo y el siguiente para decidir cual de los dos animar en la entrada y salida.
 
@@ -281,13 +281,13 @@ Derivar el estado conduce al código verboso y hace que tus componentes sean dif
 
 * Si necesitas **realizar un efecto secundario** (por ejemplo, obtención de datos o animaciones) en una respuesta debido a un cambio en los props, utiliza [`componentDidUpdate`](#componentdidupdate).
 
-* Si quieres **re calcular algunos datos solo cuando un prop cambie **,[usa memoization](/blog/2018/06/07/you-probably-dont-need-derived-state.html#what-about-memoization).
+* Si quieres **recalcular algunos datos solo cuando un prop cambie**,[usa memoization](/blog/2018/06/07/you-probably-dont-need-derived-state.html#what-about-memoization).
 
-* Si quieres ** restablecer algún state cuando un prop cambie** considera hacer un componente[ completamente controlado](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-controlled-component) o [un componente no controlado con una `key`](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-uncontrolled-component-with-a-key).
+* Si quieres **restablecer algún estado cuando un prop cambie** considera hacer un [completamente controlado](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-controlled-component) o [un componente no controlado con una `key`](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-uncontrolled-component-with-a-key).
 
-Este método no tiene acceso a la instancia del componente. Si quieres, puedes reutilizar algún código entre `getDerivedStateFromProps()` y los otros métodos de clase mediante la extracción de funciones puras de los props del componente y el state fuera de la definición de clase.
+Este método no tiene acceso a la instancia del componente. Si quieres, puedes reutilizar algún código entre `getDerivedStateFromProps()` y los otros métodos de clase mediante la extracción de funciones puras de los props del componente y el estado fuera de la definición de clase.
 
-Ten en cuenta que este método se activa en *cada* renderizado, independientemente de la causa. En caso contrario, `UNSAFE_componentWillReceiveProps`, que sólo se dispara cuando el padre causa una re renderizado y no como resultado de un `setState` local.
+Ten en cuenta que este método se activa en *cada* renderizado, independientemente de la causa. En caso contrario, `UNSAFE_componentWillReceiveProps`, que sólo se dispara cuando el padre causa un nuevo renderizado y no como resultado de un `setState` local.
 
 * * *
 
@@ -315,7 +315,7 @@ En los ejemplos anteriores, es importante leer la propiedad `scrollHeight` en `g
 
 [Los límites de error](/docs/error-boundaries.html) son componentes de React que detectan errores de JavaScript en cualquier parte de su árbol de componentes secundarios, registran esos errores y muestran una IU alternativa en lugar del árbol de componentes que se colgó. Los límites de error capturan errores durante representación, en métodos de ciclo de vida y en constructores de todo el árbol debajo de ellos.
 
-Un componente definido a través de un clase se convierte en un límite de error si se define uno o ambos métodos de ciclo de vida `static getDerivedStateFromError()` o `componentDidCatch()`. Actualizar el state desde estos ciclos de vida te permite capturar eventos no controlados desde JavaScript en el árbol inferior, y mostrarlo como respuesta en la UI.
+Un componente definido a través de un clase se convierte en un límite de error si se define uno o ambos métodos de ciclo de vida `static getDerivedStateFromError()` o `componentDidCatch()`. Actualizar el estado desde estos ciclos de vida te permite capturar eventos no controlados desde JavaScript en el árbol inferior, y mostrarlo como respuesta en la interfaz de usuario.
 
 Usa solo límites de error para recuperar excepciones inesperadas; no intentes usarlos para controlar el flujo
 
@@ -331,7 +331,7 @@ Para mas detalles ve el [*Manejo de Errores en React 16*](/blog/2017/07/26/error
 static getDerivedStateFromError(error)
 ```
 
-Este ciclo de vida se invoca después de que un error haya sido lanzado por un componente descendiente. Recibe el error que fue lanzado como parámetro y debe devolver un valor para actualizar el state.
+Este ciclo de vida se invoca después de que un error haya sido lanzado por un componente descendiente. Recibe el error que fue lanzado como parámetro y debe devolver un valor para actualizar el estado.
 
 ```js{7-10,13-16}
 class ErrorBoundary extends React.Component {
@@ -347,7 +347,7 @@ class ErrorBoundary extends React.Component {
 
   render() {
     if (this.state.hasError) {
-      // Puedes renderizar cualquier UI diferente
+      // Puedes renderizar cualquier interfaz de usuario diferente
       return <h1>Something went wrong.</h1>;
     }
 
@@ -398,7 +398,7 @@ class ErrorBoundary extends React.Component {
 
   render() {
     if (this.state.hasError) {
-      // Puedes renderizar una UI customizada
+      // Puedes renderizar una interfaz de usuario customizada
       return <h1>Something went wrong.</h1>;
     }
 
@@ -409,7 +409,7 @@ class ErrorBoundary extends React.Component {
 
 > Nota
 >
-> En el evento de un error, puedes renderizar una UI con `componentDidCatch()` llamando a `setState()`, pero esto estará obsoleto en una futura versión. Usa `static getDerivedStateFromError()` para controlar el plan de renderizado.
+> En el evento de un error, puedes renderizar una interfaz de usuario con `componentDidCatch()` llamando a `setState()`, pero esto estará obsoleto en una futura versión. Usa `static getDerivedStateFromError()` para controlar el plan de renderizado.
 
 * * *
 
@@ -428,7 +428,7 @@ UNSAFE_componentWillMount()
 > Este ciclo de vida se llamaba anteriormente `componentWillMount`. Ese nombre seguirá funcionando hasta la versión 17. Usa la [`rename-unsafe-lifecycles` codemod](https://github.com/reactjs/react-codemod#rename-unsafe-lifecycles) para actualizar automaticamente tus componentes.
 
 `UNSAFE_componentWillMount()` se invoca justo antes de que el montaje ocurra. Es llamado antes de `render()`, por lo tanto, al llamar a `setState()` de forma síncrona en este método no se activará una representación adicional.
-En general, recomendamos usar el `constructor()` en lugar de inicializar el state.
+En general, recomendamos usar el `constructor()` en lugar de inicializar el estado.
 
 Evite introducir efectos secundarios o suscripciones en este método. Para estos casos de uso, use `componentDidMount()` en su lugar.
 
@@ -451,10 +451,10 @@ UNSAFE_componentWillReceiveProps(nextProps)
 > El uso de este método de ciclo de vida a menudo conduce a errores e inconsistencias
 >
 > * Si necesitas **realizar un efecto secundario** (por ejemplo, obtención de datos o animaciones) en una respuesta debido a un cambio en los props, utiliza [`componentDidUpdate`](#componentdidupdate).
-> * Si usaste `componentWillReceiveProps` para **re calcular algunos datos cuando un prop cambie**, [utiliza memoization](/blog/2018/06/07/you-probably-dont-need-derived-state.html#what-about-memoization).
-> * Si quieres ** restablecer algún state cuando un prop cambie** considera hacer un componente[completamente controlado](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-controlled-component) o [un componente no controlado con una `key/clave`](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-uncontrolled-component-with-a-key).
+> * Si usaste `componentWillReceiveProps` para **re-calcular algunos datos cuando un prop cambie**, [utiliza memoization](/blog/2018/06/07/you-probably-dont-need-derived-state.html#what-about-memoization).
+> * Si quieres **restablecer algún state cuando un prop cambie** considera hacer un [completamente controlado](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-controlled-component) o [un componente no controlado con una `key/clave`](/blog/2018/06/07/you-probably-dont-need-derived-state.html#recommendation-fully-uncontrolled-component-with-a-key).
 >
-> Para otros casos de uso, [sigue las recomendaciones en este blog sobre state derivado](/blog/2018/06/07/you-probably-dont-need-derived-state.html).
+> Para otros casos de uso, [sigue las recomendaciones en este blog sobre estado derivado](/blog/2018/06/07/you-probably-dont-need-derived-state.html).
 
 `UNSAFE_componentWillReceiveProps()` se invoca antes de que un componente montado reciba nuevos props. Si necesita actualizar el estado en respuesta a cambios de accesorios (por ejemplo, para restablecerlo), puede comparar `this.props` y `nextProps` y realizar transiciones de estado usando `this.setState ()` en este método.
 
@@ -475,7 +475,7 @@ UNSAFE_componentWillUpdate(nextProps, nextState)
 >
 > 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.
 
-`UNSAFE_componentWillUpdate()` se invoca justo antes de renderizar cuando llegan nuevos props o se esta recibiendo el state. Use esto como una oportunidad para realizar la preparación antes de que ocurra una actualización. Este método no es llamado para el renderizador inicial.
+`UNSAFE_componentWillUpdate()` se invoca justo antes de renderizar cuando llegan nuevos props o se esta recibiendo el estado. Use esto como una oportunidad para realizar la preparación antes de que ocurra una actualización. Este método no es llamado para el renderizador inicial.
 
 No puedes llamar aquí a `this.setState()`; tampoco deberias hacer nada más (por ejemplo, enviar una acción de Redux) que activaría una actualización de un componente React antes de que devuelva el método `UNSAFE_componentWillUpdate ()`.
 
@@ -513,7 +513,7 @@ El primer argumento es una función `updater` con la firma:
 (state, props) => stateChange
 ```
 
-`state` es una referencia al estado del componente en el momento en que se está aplicando el cambio. No debería ser mutado directamente. En cambio, los cambios deberían ser representados construyendo un nuevo objeto basado en la entrada de `prevState` y `props`. Por ejemplo, supongamos que quisiéramos incrementar un valor en el state por `props.step`:
+`state` es una referencia al estado del componente en el momento en que se está aplicando el cambio. No debería ser mutado directamente. En cambio, los cambios deberían ser representados construyendo un nuevo objeto basado en la entrada de `prevState` y `props`. Por ejemplo, supongamos que quisiéramos incrementar un valor en el estado por `props.step`:
 
 ```javascript
 this.setState((state, props) => {
@@ -548,7 +548,7 @@ Object.assign(
 )
 ```
 
-Las llamadas posteriores anularán los valores de llamadas anteriores en el mismo ciclo, por lo que la cantidad solo se incrementará una vez. Si el siguiente state depende del state actual, recomendamos utilizar una actualizador a través de una función formulario.
+Las llamadas posteriores anularán los valores de llamadas anteriores en el mismo ciclo, por lo que la cantidad solo se incrementará una vez. Si el siguiente estado depende del estado actual, recomendamos utilizar una actualizador a través de una función formulario.
 
 ```js
 this.setState((state) => {
@@ -558,9 +558,9 @@ this.setState((state) => {
 
 Para más detalles, visite:
 
-* [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)
+* [Guía: Estado y ciclo de vida](/docs/state-and-lifecycle.html)
+* [En profundidad: ¿Cuándo y por qué las llamadas de `setState()` se hacen en lotes?](https://stackoverflow.com/a/48610973/458193)
+* [En profundidad: ¿Por qué `this.state` no se actualiza inmediatamente?](https://github.com/facebook/react/issues/11527#issuecomment-360199710)
 
 * * *
 
@@ -598,7 +598,7 @@ Si `props.color` no es proporcionado, se establecerá por defecto a `'blue'`:
 
 ```js
   render() {
-    return <CustomButton /> ; // props.color will be set to blue
+    return <CustomButton /> ; // props.color será asignado a azul
   }
 ```
 
@@ -606,7 +606,7 @@ Si `props.color` es null, permanecerá null:
 
 ```js
   render() {
-    return <CustomButton color={null} /> ; // props.color will remain null
+    return <CustomButton color={null} /> ; // props.color se mantendrá en null
   }
 ```
 
@@ -626,11 +626,11 @@ La cadena `displayName` es usada en la depuración de mensajes. Por lo general,
 
 En particular, `this.props.children` es un accesorio especial, tipicamente definido por las etiquetas hijas en la expresión JSX en vez de en la etiqueta como tal.
 
-### `state` {#state}
+### `Estado` {#state}
 
-El state contiene datos específicos a este componente que pueden cambiar con el tiempo. El estado está definido por el usuario, y debe ser un simple objeto JavaScript.
+El estado contiene datos específicos de este componente que pueden cambiar con el tiempo. El estado está definido por el usuario, y debe ser un simple objeto JavaScript.
 
-Si no se utiliza algún valor para renderizar o simplemente flujos de datos (por ejemplo, un ID de temporizador), no tiene que ponerlo en el state. Dichos valores se pueden definir como campos en la instancia del componente.
+Si no se utiliza algún valor para renderizar o simplemente flujos de datos (por ejemplo, un ID de temporizador), no tiene que ponerlo en el estado. Dichos valores se pueden definir como campos en la instancia del componente.
 
 Consulta [Estado y Ciclo de Vida](/docs/state-and-lifecycle.html) para mas información sobre el estado.
 
diff --git a/content/docs/reference-react-dom-server.md b/content/docs/reference-react-dom-server.md
index ba5e2ac5c..cae7e2b1f 100644
--- a/content/docs/reference-react-dom-server.md
+++ b/content/docs/reference-react-dom-server.md
@@ -9,7 +9,7 @@ permalink: docs/react-dom-server.html
 El objeto `ReactDOMServer` te permite renderizar componentes a un marcado estático. Normalmente, se usa en un servidor de Node:
 
 ```js
-// ES modules
+// módulos ES
 import ReactDOMServer from 'react-dom/server';
 // CommonJS
 var ReactDOMServer = require('react-dom/server');
@@ -37,7 +37,7 @@ Estos métodos adicionales dependen de un paquete (`stream`) que **solo está di
 ReactDOMServer.renderToString(element)
 ```
 
-Renderiza un elemento React a su HTML inicial. React devolverá HTML en una cadena de texto. Puedes usar este método para generar HTML en el servidor y enviar el marcado en la solicitud inicial para que las páginas se carguen más rápido y permitir que los motores de búsqueda rastreen sus páginas con fines de SEO.
+Renderiza un elemento React a su HTML inicial. React devolverá HTML en una cadena de texto. Puedes usar este método para generar HTML en el servidor y enviar el marcado en la solicitud inicial para que las páginas se carguen más rápido y permitir que los motores de búsqueda rastreen tus páginas con fines de SEO.
 
 Si llamas [`ReactDOM.hydrate()`](/docs/react-dom.html#hydrate) a un nodo que ya tiene este marcado desde el servidor, React lo conservará y solo adjuntará los controladores de eventos, lo que te permitirá tener una experiencia de primera carga muy eficaz.
 
diff --git a/content/docs/reference-react-dom.md b/content/docs/reference-react-dom.md
index a4e9b6b09..b902e8967 100644
--- a/content/docs/reference-react-dom.md
+++ b/content/docs/reference-react-dom.md
@@ -50,7 +50,7 @@ Si se suministra el *callback* opcional, será ejecutado después de que el comp
 >
 > `ReactDOM.render()` actualmente retorna una referencia a la instancia `ReactComponent` raíz. Sin embargo, utilizar este valor retornado es una práctica vieja,
 > y debe ser evitada debido a que en futuras versiones de React puede que los componentes se rendericen de manera asíncrona en algunos casos. Si deseas obtener una referencia a la instancia `ReactComponent` raíz,
-> la solución preferida es agregar una [referencia mediante callback](/docs/more-about-refs.html#the-ref-callback-attribute) al elemento raíz.
+> la solución preferida es agregar una [referencia mediante callback](/docs/more-about-refs.html#callback-refs) al elemento raíz.
 >
 > El uso de `ReactDOM.render()` para hidratar un contenedor renderizado por servidor esta despreciado, y será eliminado en la versión 17 de React. Usa en su lugar [`hydrate()`](#hydrate).
 
diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 86c4e87e8..b114ddffe 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -88,7 +88,7 @@ Los *Hooks* son una nueva adición en React 16.8. Permiten usar el estado y otra
 
 ### `React.Component` {#reactcomponent}
 
-`React.Component` es la clase base para los componentes de React cuando estos son definidos usando [clases ES6](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Classes):
+`React.Component` es la clase base para los componentes de React cuando estos son definidos usando [clases ES6](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Classes):
 
 ```javascript
 class Greeting extends React.Component {
@@ -186,7 +186,7 @@ Clona y retorna un elemento React usando `element` como punto de partida. El ele
 <element.type {...element.props} {...props}>{children}</element.type>
 ```
 
-Sin embargo, también preserva los `ref`s. Esto significa que, si se obtiene un hijo con un `ref` en él, no lo robará accidentalmente de su precedente. Se obtendrá el mismo `ref` adjunto al nuevo elemento.
+Sin embargo, también preserva los `refs`. Esto significa que, si se obtiene un hijo con un `ref` en él, no lo robará accidentalmente de su precedente. Se obtendrá el mismo `ref` adjunto al nuevo elemento.
 
 Esta API fue introducida como un reemplazo al obsoleto `React.addons.cloneWithProps()`.
 
@@ -312,7 +312,7 @@ En el ejemplo anterior, React pasa un `ref` dado a un elemento `<FancyButton ref
 
 Como resultado, después que React adjunte el ref, `ref.current` apuntará directamente a la instancia del elemento DOM `<button>`.
 
-Para más información, ver [enviando refs](/docs/forwarding-refs.html).
+Para más información, ver [reenvío de refs](/docs/forwarding-refs.html).
 
 ### `React.lazy` {#reactlazy}
 
diff --git a/content/docs/reference-test-renderer.md b/content/docs/reference-test-renderer.md
index ff322af42..395ec9735 100644
--- a/content/docs/reference-test-renderer.md
+++ b/content/docs/reference-test-renderer.md
@@ -10,14 +10,14 @@ category: Referencia
 
 ```javascript
 import TestRenderer from 'react-test-renderer'; // ES6
-const TestRenderer = require('react-test-renderer'); // ES5 with npm
+const TestRenderer = require('react-test-renderer'); // ES5 con npm
 ```
 
 ## Resumen {#overview}
 
 Este paquete proporciona un procesador de React que se puede usar para procesar componentes de React a objetos JavaScript puros, sin depender del DOM o de un entorno móvil nativo.
 
-Básicamente, este paquete facilita tomar una instantánea de la jerarquía de la vista de la plataforma (similar a un árbol DOM) representada por un componente React DOM o React Nativo sin usar un navegador o [jsdom](https://github.com/tmpvar/jsdom).
+Básicamente, este paquete facilita tomar una instantánea de la jerarquía de la vista de la plataforma (similar a un árbol DOM) representada por un componente React DOM o React Native sin usar un navegador o [jsdom](https://github.com/tmpvar/jsdom).
 
 Ejemplo:
 
@@ -198,9 +198,7 @@ Busca todos los objetos `test instance` descendientes con el tipo (`type`) pasad
 testInstance.findAllByProps(props)
 ```
 
-
 Busca todos los objetos `test instance` descendientes con los `props` pasados como argumento.
-Find all descendant test instances with the provided `props`.
 
 ### `testInstance.instance` {#testinstanceinstance}
 
@@ -268,7 +266,7 @@ TestRenderer.create(
   {
     createNodeMock: (element) => {
       if (element.type === 'input') {
-        // mock a focus function
+        // simula una función de enfoque
         return {
           focus: () => {
             focused = true;
diff --git a/content/docs/rendering-elements.md b/content/docs/rendering-elements.md
index 57f63d660..c0ca99573 100644
--- a/content/docs/rendering-elements.md
+++ b/content/docs/rendering-elements.md
@@ -13,7 +13,7 @@ Los elementos son los bloques más pequeños de las aplicaciones de React.
 Un elemento describe lo que quieres ver en la pantalla:
 
 ```js
-const element = <h1>Hola, mundo</h1>;
+const element = <h1>Hello, world</h1>;
 ```
 
 A diferencia de los elementos del DOM de los navegadores, los elementos de React son objetos planos, y su creación es de bajo costo. React DOM se encarga de actualizar el DOM para igualar los elementos de React.
@@ -44,9 +44,9 @@ Esto muestra "Hello, world" en la página.
 
 ## Actualizando el elemento renderizado {#updating-the-rendered-element}
 
-Los elementos de React son [inmutables](https://en.wikipedia.org/wiki/Immutable_object). Una vez creas un elemento, no puedes cambiar sus hijos o atributos. Un elemento es como un fotograma solitario en una película: este representa la IU en cierto punto en el tiempo.
+Los elementos de React son [inmutables](https://es.wikipedia.org/wiki/Objeto_inmutable). Una vez creas un elemento, no puedes cambiar sus hijos o atributos. Un elemento es como un fotograma solitario en una película: este representa la interfaz de usuario en cierto punto en el tiempo.
 
-Con nuestro conocimiento hasta este punto, la única manera de actualizar la IU es creando un nuevo elemento, y pasarlo a `ReactDOM.render()`.
+Con nuestro conocimiento hasta este punto, la única manera de actualizar la interfaz de usuario es creando un nuevo elemento, y pasarlo a `ReactDOM.render()`.
 
 Considera este ejemplo de un reloj en marcha:
 
@@ -54,7 +54,7 @@ Considera este ejemplo de un reloj en marcha:
 
 [](codepen://rendering-elements/update-rendered-element)
 
-Este llama a `ReactDOM.render()` cada segundo desde un [`setInterval()`](https://developer.mozilla.org/en-US/docs/Web/API/WindowTimers/setInterval) callback.
+Este llama a `ReactDOM.render()` cada segundo desde un callback del [`setInterval()`](https://developer.mozilla.org/en-US/docs/Web/API/WindowTimers/setInterval).
 
 >**Nota:**
 >
@@ -70,6 +70,6 @@ Puedes verificar esto inspeccionando el [último ejemplo](codepen://rendering-el
 
 ![inspector del DOM mostrando actualizaciones diminutas](../images/docs/granular-dom-updates.gif)
 
-Aunque creamos un elemento que describe el árbol de la IU en su totalidad en cada instante, React DOM solo actualiza el texto del nodo cuyo contenido cambió.
+Aunque creamos un elemento que describe el árbol de la interfaz de usuario en su totalidad en cada instante, React DOM solo actualiza el texto del nodo cuyo contenido cambió.
 
-En nuestra experiencia, pensar en cómo la IU debería verse en un momento dado y no en cómo cambiarla en el tiempo, elimina toda una clase de errores.
+En nuestra experiencia, pensar en cómo la interfaz de usuario debería verse en un momento dado y no en cómo cambiarla en el tiempo, elimina toda una clase de errores.
diff --git a/content/docs/state-and-lifecycle.md b/content/docs/state-and-lifecycle.md
index 22c2f451d..1bc466538 100644
--- a/content/docs/state-and-lifecycle.md
+++ b/content/docs/state-and-lifecycle.md
@@ -10,7 +10,7 @@ next: handling-events.html
 
 Esta página introduce el concepto de estado y ciclo de vida en un componente de React. Puedes encontrar una [referencia detallada de la API de un componente aquí](/docs/react-component.html).
 
-Consideremos el ejemplo del reloj de [una de las secciones anteriores](/docs/rendering-elements.html#updating-the-rendered-element). En [Renderizando elementos](/docs/rendering-elements.html#rendering-an-element-into-the-dom), aprendimos solo una forma de actualizar la IU. Invocamos a `ReactDOM.render()` para que cambie el resultado renderizado.
+Consideremos el ejemplo del reloj de [una de las secciones anteriores](/docs/rendering-elements.html#updating-the-rendered-element). En [Renderizando elementos](/docs/rendering-elements.html#rendering-an-element-into-the-dom), aprendimos solo una forma de actualizar la interfaz de usuario. Invocamos a `ReactDOM.render()` para que cambie el resultado renderizado.
 
 ```js{8-11}
 function tick() {
@@ -31,7 +31,7 @@ setInterval(tick, 1000);
 
 [**Pruébalo en CodePen**](http://codepen.io/gaearon/pen/gwoJZk?editors=0010)
 
-En esta sección, aprenderemos como hacer al componente `Clock` verdaderamente reutilizable y encapsulado. Configurará su propio temporizador y se actualizará cada segundo.
+En esta sección, aprenderemos como hacer al componente `Clock` verdaderamente reutilizable y encapsulado. Configurarás tu propio temporizador y se actualizará cada segundo.
 
 Podemos comenzar por encapsular cómo se ve el reloj:
 
@@ -57,7 +57,7 @@ setInterval(tick, 1000);
 
 [**Pruébalo en CodePen**](http://codepen.io/gaearon/pen/dpdoYR?editors=0010)
 
-Sin embargo, se pierde un requisito crucial: el hecho de que `Clock` configure un temporizador y actualice la IU cada segundo debe ser un detalle de implementación de `Clock`.
+Sin embargo, se pierde un requisito crucial: el hecho de que `Clock` configure un temporizador y actualice la interfaz de usuario cada segundo debe ser un detalle de implementación de `Clock`.
 
 Idealmente, queremos escribir esto una vez y que `Clock` se actualice a sí mismo:
 
@@ -314,7 +314,7 @@ Repasemos rápidamente lo que está sucediendo y el orden en que se invocan los
 
 3) Cuando la salida de `Clock` se inserta en el DOM, React invoca al método de ciclo de vida `componentDidMount()`. Dentro de él, el componente `Clock` le pide al navegador que configure un temporizador para invocar al método `tick()` del componente una vez por segundo.
 
-4) Cada segundo el navegador invoca al método `tick()`. Dentro de él, el componente `Clock` planifica una actualización de la IU al invocar a `setState()` con un objeto que contiene la hora actual. Gracias a la invocación a `setState()`, React sabe que el estado cambió e invoca de nuevo al método `render()` para saber qué debe estar en la pantalla. Esta vez, `this.state.date` en el método `render()` será diferente, por lo que el resultado del renderizado incluirá la hora actualizada. Conforme a eso React actualiza el DOM.
+4) Cada segundo el navegador invoca al método `tick()`. Dentro de él, el componente `Clock` planifica una actualización de la interfaz de usuario al invocar a `setState()` con un objeto que contiene la hora actual. Gracias a la invocación a `setState()`, React sabe que el estado cambió e invoca de nuevo al método `render()` para saber qué debe estar en la pantalla. Esta vez, `this.state.date` en el método `render()` será diferente, por lo que el resultado del renderizado incluirá la hora actualizada. Conforme a eso React actualiza el DOM.
 
 5) Si el componente `Clock` se elimina en algún momento del DOM, React invoca al método de ciclo de vida `componentWillUnmount()`, por lo que el temporizador se detiene.
 
@@ -439,7 +439,7 @@ function FormattedDate(props) {
 
 [**Pruébalo en CodePen**](http://codepen.io/gaearon/pen/zKRqNB?editors=0010)
 
-A esto comúnmente se le llama flujo de datos «descendente» o «unidireccional». Cualquier estado siempre es propiedad de algún componente específico, y cualquier dato o IU derivados de ese estado solo pueden afectar los componentes «debajo» de ellos en el árbol.
+A esto comúnmente se le llama flujo de datos «descendente» o «unidireccional». Cualquier estado siempre es propiedad de algún componente específico, y cualquier dato o interfaz de usuario derivados de ese estado solo pueden afectar los componentes «debajo» de ellos en el árbol.
 
 Si imaginas un árbol de componentes como una cascada de props, el estado de cada componente es como una fuente de agua adicional que se le une en un punto arbitrario, pero también fluye hacia abajo.
 
diff --git a/content/docs/static-type-checking.md b/content/docs/static-type-checking.md
index d8046ccd2..96f026aee 100644
--- a/content/docs/static-type-checking.md
+++ b/content/docs/static-type-checking.md
@@ -256,7 +256,7 @@ Abordaremos esto en dos pasos:
 En general, no deseas mantener el javascript generado en tu control de código fuente, así que asegúrate de agregar la carpeta de compilación a tu `.gitignore`.
 
 ### Extensiones de archivo {#file-extensions}
-En React, lo más probable es que escribas tus componentes en un archivo `.js`. En TypeScript tenemos 2 extensiones de archivo.:
+En React, lo más probable es que escribas tus componentes en un archivo `.js`. En TypeScript tenemos 2 extensiones de archivo:
 
 `.ts` es la extensión de archivo predeterminada, mientras que `.tsx` es una extensión especial que se usa para los archivos que contienen `JSX`.
 
@@ -280,7 +280,7 @@ Si no ves ninguna salida, significa que se completó correctamente.
 ### Definiciones de tipo {#type-definitions}
 Para poder mostrar errores y sugerencias de otros paquetes, el compilador se basa en archivos de declaración. Un archivo de declaración proporciona toda la información de tipos sobre una biblioteca. Esto nos permite usar bibliotecas javascript como las que están en npm en nuestro proyecto.
 
-Hay dos formas principales de obtener declaraciones para una biblioteca.:
+Hay dos formas principales de obtener declaraciones para una biblioteca:
 
 __Integradas__ - La biblioteca incluye sus propios archivos de declaración. Esto es genial para nosotros, ya que todo lo que tenemos que hacer es instalar la biblioteca y podemos usarla de inmediato. Para verificar si una biblioteca tiene tipos integrados, busca un archivo `index.d.ts` en el proyecto. Algunas bibliotecas lo tendrán especificado en su `package.json` bajo el campo `typings` o `types`.
 
diff --git a/content/docs/strict-mode.md b/content/docs/strict-mode.md
index 00b570c10..7e2ba0ac6 100644
--- a/content/docs/strict-mode.md
+++ b/content/docs/strict-mode.md
@@ -4,7 +4,7 @@ title: Modo estricto
 permalink: docs/strict-mode.html
 ---
 
-`StrictMode` es una herramienta para destacar problemas potenciales en la aplicación. Al igual que `Fragment`, `StrictMode` no renderiza nada en la UI. Este modo también activa advertencias y comprobaciones adicionales para sus descendientes.
+`StrictMode` es una herramienta para destacar problemas potenciales en la aplicación. Al igual que `Fragment`, `StrictMode` no renderiza nada en la interfaz de usuario. Este modo también activa advertencias y comprobaciones adicionales para sus descendientes.
 
 > Nota:
 >
@@ -75,7 +75,7 @@ class MyComponent extends React.Component {
 
 > Nota:
 >
-> En CSS, el atributo [`display: contents`](https://developer.mozilla.org/en-US/docs/Web/CSS/display#display_contents) puede ser usado si no quieres que el nodo sea parte de la estructura.
+> En CSS, el atributo [`display: contents`](https://developer.mozilla.org/es/docs/Web/CSS/display#display_contents) puede ser usado si no quieres que el nodo sea parte de la estructura.
 
 ### Detectar efectos secundarios inesperados {#detecting-unexpected-side-effects}
 
@@ -95,7 +95,7 @@ El ciclo de vida de la fase de renderizado incluye los siguientes métodos de lo
 * `render`
 * Funciones de actualización de `setState` (el primer argumento)
 
-Ya que los métodos arriba mencionados pueden ser llamados más de una vez, es importante que estos no contengan ningún efecto secundario. Ignorar esta regla puede llevar a una cantidad de problemas, incluyendo fugas de memoria y estados de aplicación inválido. Desafortunadamente, puede ser muy difícil el detectar estos problemas ya con frecuencia pueden ser [no deterministas](https://en.wikipedia.org/wiki/Deterministic_algorithm).
+Ya que los métodos arriba mencionados pueden ser llamados más de una vez, es importante que estos no contengan ningún efecto secundario. Ignorar esta regla puede llevar a una cantidad de problemas, incluyendo fugas de memoria y estados de aplicación inválido. Desafortunadamente, puede ser muy difícil el detectar estos problemas ya con frecuencia pueden ser [no deterministas](https://es.wikipedia.org/wiki/Algoritmo_determinista).
 
 El modo estricto no puede detectar efectos secundarios de forma automática por ti, pero te puede ayudar a encontrarlos al hacerlos un poco más deterministas. Esto se logra al invocar dos veces los siguientes métodos:
 
@@ -111,7 +111,7 @@ El modo estricto no puede detectar efectos secundarios de forma automática por
 Por ejemplo, considera el siguiente código:
 `embed:strict-mode/side-effects-in-constructor.js`
 
-En primera instancia, este código no debería parecer problemático. Pero si `SharedApplicationState.recordEvent` no es [idempotente](https://en.wikipedia.org/wiki/Idempotence#Computer_science_meaning), entonces al instanciar este componente múltiples veces puede llevar a que tenga un estado de aplicación inválido. Estos tipo de bug sutiles pueden no manifestarse durante el desarrollo, o quizas sí lo hagan pero de forma inconsistente y se pase por alto.
+En primera instancia, este código no debería parecer problemático. Pero si `SharedApplicationState.recordEvent` no es [idempotente](https://es.wikipedia.org/wiki/Idempotencia_(inform%C3%A1tica)), entonces al instanciar este componente múltiples veces puede llevar a que tenga un estado de aplicación inválido. Estos tipo de bug sutiles pueden no manifestarse durante el desarrollo, o quizas sí lo hagan pero de forma inconsistente y se pase por alto.
 
 Al invocar los métodos dos veces, como el constructor del componente, el modo estricto hace que patrones como estos sean más fáciles de encontrar.
 
diff --git a/content/docs/thinking-in-react.md b/content/docs/thinking-in-react.md
index daeb3cb4d..8881b8b61 100644
--- a/content/docs/thinking-in-react.md
+++ b/content/docs/thinking-in-react.md
@@ -31,9 +31,9 @@ Nuestro API JSON devuelve información en el siguiente formato:
 ];
 ```
 
-## Paso 1: Divide la UI en una jerarquía de componentes {#step-1-break-the-ui-into-a-component-hierarchy}
+## Paso 1: Divide la interfaz de usuario en una jerarquía de componentes {#step-1-break-the-ui-into-a-component-hierarchy}
 
-Lo Primero que vas a querer hacer es dibujar cajas alrededor de cada componente (y subcomponente) en el mock y darles nombres a todos ellos. Si trabajas con un diseñador, probablemente ya lo hayan hecho ¡Así que ve a hablar con ellos! ¡Los nombres de sus capas de Photoshop podrían terminar siendo los nombres de tus componentes de React!
+Lo primero que vas a querer hacer es dibujar cajas alrededor de cada componente (y subcomponente) en el mock y darles nombres a todos ellos. Si trabajas con un diseñador, probablemente ya lo hayan hecho ¡Así que ve a hablar con ellos! ¡Los nombres de sus capas de Photoshop podrían terminar siendo los nombres de tus componentes de React!
 
 ¿Pero cómo sabes qué debería ser su propio componente? Usa las mismas técnicas para decidir si deberías crear una función u objeto nuevo. Una técnica es el [principio de responsabilidad única](https://es.wikipedia.org/wiki/Principio_de_responsabilidad_%C3%BAnica), esto significa que un componente debe, idealmente, hacer solo una cosa. Si termina creciendo entonces debería ser dividido en componentes más pequeños.
 
@@ -49,7 +49,7 @@ Verás que tenemos cinco componentes en nuestra aplicación de ejemplo. Hemos es
   4. **`ProductCategoryRow` (turquoise):** muestra el encabezado de cada *categoría*
   5. **`ProductRow` (red):** muestra una fila por cada *producto*
 
-Si observas `ProductTable`, verás que el encabezado de la tabla (conteniendo las etiquetas "Nombre" y "Precio") no son sus propios componentes. Esto es cuestión de preferencia, y hay argumentos para hacerlo de ambas formas. Para este ejemplo, decidimos dejarlos como parte de `ProductTable` porque es parte de representar la *colección de datos*, que es parte de las responsabilidades de `ProductTable`. De todas formas, si este encabezado crece hasta volverse demasiado complejo (por ejemplo, si tuviéramos que agregar una forma de ordenarlos), tendría sentido entonces que sean su propio componente `ProductTableHeader`.
+Si observas `ProductTable`, verás que el encabezado de la tabla (conteniendo las etiquetas "Name" y "Price") no son sus propios componentes. Esto es cuestión de preferencia, y hay argumentos para hacerlo de ambas formas. Para este ejemplo, decidimos dejarlos como parte de `ProductTable` porque es parte de representar la *colección de datos*, que es parte de las responsabilidades de `ProductTable`. De todas formas, si este encabezado crece hasta volverse demasiado complejo (por ejemplo, si tuviéramos que agregar una forma de ordenarlos), tendría sentido entonces que sean su propio componente `ProductTableHeader`.
 
 Ahora que hemos identificado los componentes en nuestro mock, vamos a ordenarlos jerárquicamente. Esto es fácil. Los componentes que aparecen dentro de otro componente en nuestro mock deberían aparecer como hijos en la jerarquía.
 
@@ -61,7 +61,7 @@ Ahora que hemos identificado los componentes en nuestro mock, vamos a ordenarlos
 
 ## Paso 2: Crea una versión estática en React {#step-2-build-a-static-version-in-react}
 
-<p data-height="600" data-theme-id="0" data-slug-hash="BwWzwm" data-default-tab="js" data-user="lacker" data-embed-version="2" class="codepen">Revisa el Pen <a href="https://codepen.io/gaearon/pen/BwWzwm">Pensando en React: Paso 2</a> en <a href="http://codepen.io">CodePen</a>.</p>
+<p data-height="600" data-theme-id="0" data-slug-hash="BwWzwm" data-default-tab="js" data-user="lacker" data-embed-version="2" class="codepen">Revisa el código <a href="https://codepen.io/gaearon/pen/BwWzwm">Pensando en React: Paso 2</a> en <a href="http://codepen.io">CodePen</a>.</p>
 <script async src="https://production-assets.codepen.io/assets/embed/ei.js"></script>
 
 Ahora que tenemos nuestra jerarquía de componentes, es momento de implementar la aplicación. La forma más fácil es construir una versión que tome nuestro modelo de datos y muestre la interfaz de usuario sin interactividad. Es mejor desacoplar estos procesos porque crear una versión estática requiere escribir un montón pero no pensar tanto, mientras que agregar interactividad requiere pensar un montón y no escribir tanto. Vamos a ver por qué.
@@ -106,7 +106,7 @@ Finalmente, nuestro estado es:
 
 ## Paso 4: Identificar donde debe vivir tu estado {#step-4-identify-where-your-state-should-live}
 
-<p data-height="600" data-theme-id="0" data-slug-hash="qPrNQZ" data-default-tab="js" data-user="lacker" data-embed-version="2" class="codepen">Revisa el Pen <a href="https://codepen.io/gaearon/pen/qPrNQZ">Pensando en React: Paso 4</a> en <a href="http://codepen.io">CodePen</a>.</p>
+<p data-height="600" data-theme-id="0" data-slug-hash="qPrNQZ" data-default-tab="js" data-user="lacker" data-embed-version="2" class="codepen">Revisa el código <a href="https://codepen.io/gaearon/pen/qPrNQZ">Pensando en React: Paso 4</a> en <a href="http://codepen.io">CodePen</a>.</p>
 
 Bien, hemos identificado la mínima cantidad de estado en la aplicación. Lo siguiente que necesitamos hacer es identificar que componentes modifican o *son dueños* de este estado.
 
@@ -131,7 +131,7 @@ Ya puedes ir viendo como tu aplicación se va a comportar. Cambia `filterText` a
 
 ## Paso 5: Agregar flujo de datos inverso {#step-5-add-inverse-data-flow}
 
-<p data-height="600" data-theme-id="0" data-slug-hash="LzWZvb" data-default-tab="js,result" data-user="rohan10" data-embed-version="2" data-pen-title="Thinking In React: Step 5" class="codepen">Revisa el Pen <a href="https://codepen.io/gaearon/pen/LzWZvb">Pensando en React: Paso 5</a> e  <a href="http://codepen.io">CodePen</a>.</p>
+<p data-height="600" data-theme-id="0" data-slug-hash="LzWZvb" data-default-tab="js,result" data-user="rohan10" data-embed-version="2" data-pen-title="Thinking In React: Step 5" class="codepen">Revisa el código <a href="https://codepen.io/gaearon/pen/LzWZvb">Pensando en React: Paso 5</a> e  <a href="http://codepen.io">CodePen</a>.</p>
 
 Hasta ahora, hemos creado una aplicación que funciona correctamente como una función de los props y estado fluyendo hacia abajo en la jerarquía. Es momento entonces de empezar a soportar que los datos fluyan en el otro sentido: el componente de formulario ubicado más abajo en la jerarquía necesita actualizar el estado en `FilterableProductTable`.
 
diff --git a/content/docs/typechecking-with-proptypes.md b/content/docs/typechecking-with-proptypes.md
index 37c0eba2e..c61271813 100644
--- a/content/docs/typechecking-with-proptypes.md
+++ b/content/docs/typechecking-with-proptypes.md
@@ -58,7 +58,7 @@ MyComponent.propTypes = {
   optionalElement: PropTypes.element,
 
   // Además puedes declarar que una prop es una instancia de una clase. Este usa
-  // el operador instanceof de Js.
+  // el operador instanceof de JS.
   optionalMessage: PropTypes.instanceOf(Message),
 
   // Puedes asegurar que una prop esta limitada a valores específicos si se
diff --git a/content/docs/uncontrolled-components.md b/content/docs/uncontrolled-components.md
index 602344017..9a17def12 100644
--- a/content/docs/uncontrolled-components.md
+++ b/content/docs/uncontrolled-components.md
@@ -68,7 +68,7 @@ Del mismo modo, `<input type="checkbox">` e `<input type="radio">` admiten `defa
 
 ## La etiqueta de entrada de archivo {#the-file-input-tag}
 
-En HTML, un `<input type="file">` permite al usuario elegir uno o más archivos del almacenamiento en sus dispositivos para cargarlos a un servidor o manipularlos mediante JavaScript a través de la [API File](https://developer.mozilla.org/es/docs/Web/API/File/Using_files_from_web_applications).
+En HTML, un `<input type="file">` permite al usuario elegir uno o más archivos del almacenamiento en sus dispositivos para cargarlos a un servidor o manipularlos mediante JavaScript a través de la [API de archivos](https://developer.mozilla.org/es/docs/Web/API/File/Using_files_from_web_applications).
 
 ```html
 <input type="file" />
diff --git a/content/docs/web-components.md b/content/docs/web-components.md
index de2adbc4b..67329953b 100644
--- a/content/docs/web-components.md
+++ b/content/docs/web-components.md
@@ -8,7 +8,7 @@ redirect_from:
 
 React y [Web Components](https://developer.mozilla.org/es/docs/Web/Web_Components) están construidos para resolver diferentes problemas. Los Web Components proporciona una fuerte encapsulación para componentes reutilizables, mientras que React proporciona una biblioteca declarativa que mantiene el DOM sincronizado con tus datos. Los dos objetivos se complementan. Como desarrollador, eres libre de usar React en tus Web Components, utilizar Web Components en React, o ambos.
 
-La mayoría de las personas que usan React no utilizan Web Components, pero es posible que desees hacerlo, especialmente si estás utilizando componentes de IU de terceros que se escriben utilizando Web Components.
+La mayoría de las personas que usan React no utilizan Web Components, pero es posible que desees hacerlo, especialmente si estás utilizando componentes de interfaz de usuario de terceros que se escriben utilizando Web Components.
 
 ## Usando Web Components en React {#using-web-components-in-react}
 
@@ -58,5 +58,5 @@ customElements.define('x-search', XSearch);
 
 >Nota:
 >
->Este código **NO** funcionará si transformas clases con Babel. Ver [Este asunto](https://github.com/w3c/webcomponents/issues/587) para la discusión.
+>Este código **NO** funcionará si transformas clases con Babel. Ver [Este caso](https://github.com/w3c/webcomponents/issues/587) para la discusión.
 >Incluye el [custom-elements-es5-adapter](https://github.com/webcomponents/webcomponentsjs#custom-elements-es5-adapterjs) antes de cargar tus Web Components para que puedas solucionar este problema.
diff --git a/examples/forwarding-refs/fancy-button-ref.js b/examples/forwarding-refs/fancy-button-ref.js
index 36e15dd2d..6df57b055 100644
--- a/examples/forwarding-refs/fancy-button-ref.js
+++ b/examples/forwarding-refs/fancy-button-ref.js
@@ -3,10 +3,10 @@ import FancyButton from './FancyButton';
 // highlight-next-line
 const ref = React.createRef();
 
-// The FancyButton component we imported is the LogProps HOC.
-// Even though the rendered output will be the same,
-// Our ref will point to LogProps instead of the inner FancyButton component!
-// This means we can't call e.g. ref.current.focus()
+// El componente FancyButton que importamos es el HOC LogProps.
+// Aun así la salida renderizada será la misma,
+// nuestra referencia apuntará a LogProps en lugar del componente FancyButton interno!
+// Esto significa que no podemos llamar a por ejemplo: ref.current.focus()
 // highlight-range{4}
 <FancyButton
   label="Click Me"
diff --git a/examples/forwarding-refs/fancy-button-simple-ref.js b/examples/forwarding-refs/fancy-button-simple-ref.js
index f4d5f8e0e..be4efa4f5 100644
--- a/examples/forwarding-refs/fancy-button-simple-ref.js
+++ b/examples/forwarding-refs/fancy-button-simple-ref.js
@@ -5,6 +5,6 @@ const FancyButton = React.forwardRef((props, ref) => (
   </button>
 ));
 
-// You can now get a ref directly to the DOM button:
+// Ahora puedes obtener una referencia directa al botón del DOM:
 const ref = React.createRef();
 <FancyButton ref={ref}>Click me!</FancyButton>;
diff --git a/examples/forwarding-refs/fancy-button.js b/examples/forwarding-refs/fancy-button.js
index 9dcd13e16..6898f7c2b 100644
--- a/examples/forwarding-refs/fancy-button.js
+++ b/examples/forwarding-refs/fancy-button.js
@@ -6,7 +6,7 @@ class FancyButton extends React.Component {
   // ...
 }
 
-// Rather than exporting FancyButton, we export LogProps.
-// It will render a FancyButton though.
+// En lugar de exportar FancyButton, exportamos LogProps.
+// Esto renderizará un FancyButton igualmente.
 // highlight-next-line
 export default logProps(FancyButton);
diff --git a/examples/forwarding-refs/log-props-after.js b/examples/forwarding-refs/log-props-after.js
index a603bd697..11e22e746 100644
--- a/examples/forwarding-refs/log-props-after.js
+++ b/examples/forwarding-refs/log-props-after.js
@@ -15,9 +15,9 @@ function logProps(Component) {
     }
   }
 
-  // Note the second param "ref" provided by React.forwardRef.
-  // We can pass it along to LogProps as a regular prop, e.g. "forwardedRef"
-  // And it can then be attached to the Component.
+  // Mira el segundo parámetro "ref" suministrado por React.forwardRef.
+  // Podemos pasarlo a LogProps como una prop regular, por ejemplo: "forwardedRef"
+  // Y puede ser agregado al "Component".
   // highlight-range{1-3}
   return React.forwardRef((props, ref) => {
     return <LogProps {...props} forwardedRef={ref} />;
diff --git a/examples/react-component-reference/get-snapshot-before-update.js b/examples/react-component-reference/get-snapshot-before-update.js
index cf1fb2335..0cdb1fc3b 100644
--- a/examples/react-component-reference/get-snapshot-before-update.js
+++ b/examples/react-component-reference/get-snapshot-before-update.js
@@ -5,8 +5,8 @@ class ScrollingList extends React.Component {
   }
 
   getSnapshotBeforeUpdate(prevProps, prevState) {
-    // Are we adding new items to the list?
-    // Capture the scroll position so we can adjust scroll later.
+    // ¿Estamos agregando nuevos elementos a la lista?
+    // Captura la posición del scroll para que podamos ajustar el scroll después.
     if (prevProps.list.length < this.props.list.length) {
       const list = this.listRef.current;
       return list.scrollHeight - list.scrollTop;
@@ -15,9 +15,9 @@ class ScrollingList extends React.Component {
   }
 
   componentDidUpdate(prevProps, prevState, snapshot) {
-    // If we have a snapshot value, we've just added new items.
-    // Adjust scroll so these new items don't push the old ones out of view.
-    // (snapshot here is the value returned from getSnapshotBeforeUpdate)
+    // Si tenemos un valor snapshot, agregamos nuevos elementos
+    // Ajusta el scroll para que los nuevos elementos no empujen a los viejos fuera de la vista
+    // (snapshot aquí es el valor que regresa de getSnapshotBeforeUpdate)
     if (snapshot !== null) {
       const list = this.listRef.current;
       list.scrollTop = list.scrollHeight - snapshot;