diff --git a/00_intro.md b/00_intro.md
index 1dd4fb6d0..54722af25 100644
--- a/00_intro.md
+++ b/00_intro.md
@@ -12,7 +12,7 @@ el orden, la reglas y la claridad.
 
 quote}}
 
-Este es un libro acerca de instruir ((computadora))s. Hoy en dia las
+Este es un libro acerca de instruir ((computadora))s. Hoy en día las
 computadoras son tan comunes como los destornilladores (aunque bastante más
 complejas que estos), y hacer que hagan exactamente lo que quieres que
 hagan no siempre es fácil.
@@ -34,7 +34,7 @@ Afortunadamente, si puedes superar eso, y tal vez incluso disfrutar el rigor
 de pensar en términos que las máquinas tontas puedan manejar, la programación
 puede ser muy gratificante. Te permite hacer en segundos cosas que
 tardarían _siglos_ a mano. Es una forma de hacer que tu herramienta
-computadora haga cosas que antes no podía. Ademas proporciona de un maravilloso
+computadora haga cosas que antes no podía. Además proporciona de un maravilloso
 ejercicio en pensamiento abstracto.
 
 La mayoría de la programación se realiza con ((lenguajes de programación)).
@@ -259,7 +259,7 @@ Esta versión nos da algunas mejoras más. La más importante, ya
 no hay necesidad de especificar la forma en que queremos que el programa salte
 hacia adelante y hacia atrás. El constructo del lenguaje `while` se ocupa
 de eso. Este continúa ejecutando el bloque de código (envuelto en llaves)
-debajo de el, siempre y cuando la condición que se le dio se mantenga.
+debajo de él, siempre y cuando la condición que se le dio se mantenga.
 Esa condición es `cuenta <= 10`, lo que significa "_cuenta_ es menor o igual a
 10". Ya no tenemos que crear un valor temporal y compararlo con cero,
 lo cual era un detalle poco interesante. Parte del poder de los lenguajes de
@@ -406,7 +406,7 @@ escrito una solución funcional para resolverlos.
 
 Te recomiendo que pruebes tus soluciones a los ejercicios en un intérprete real
 de JavaScript. De esta forma, obtendrás retroalimentación inmediata acerca
-de que si esta funcionando lo que estás haciendo, y, espero, serás tentado
+de que si esta funcionando lo que estás haciendo, y espero, serás tentado
 a ((experimentar)) e ir más allá de los ejercicios.
 
 {{if interactive
@@ -463,7 +463,7 @@ La parte del lenguaje del libro comienza con cuatro capítulos para presentar
 la estructura básica del lenguaje de JavaScript. Estos introducen
 [estructuras de control](estructura_de_programa) (como la palabra `while`
 que ya viste en esta introducción), [funciones](funciones) (escribir tus propios
-bloques de construcción), y [estructuras de datos](datos). Después de estos, seras
+bloques de construcción), y [estructuras de datos](datos). Después de estos, serás
 capaz de escribir programas simples. Luego, los Capítulos [5](orden_superior) y
 [6](objeto) introducen técnicas para usar funciones y objetos y asi escribir
 código más _abstracto_ y de manera que puedas mantener la complejidad bajo control.
@@ -514,7 +514,7 @@ function factorial(numero) {
 {{index "console.log"}}
 
 Algunas veces, para mostrar el resultado que produce un programa,
-la salida esperada se escribe después de el, con dos diagonales y una flecha en
+la salida esperada se escribe después de él, con dos diagonales y una flecha en
 frente.
 
 ```
diff --git a/01_values.md b/01_values.md
index f1fe11f7b..06e43e8e4 100644
--- a/01_values.md
+++ b/01_values.md
@@ -34,11 +34,11 @@ de esa manera ser representada en bits.
 
 {{index "binary number", radix, "decimal number"}}
 
-Por ejemplo, podemos expresar el numero 13 en bits. Funciona de la misma
+Por ejemplo, podemos expresar el número 13 en bits. Funciona de la misma
 manera que un número decimal, pero en vez de 10 diferentes dígitos, solo
 tienes 2, y el peso de cada uno aumenta por un factor de 2 de derecha a
 izquierda. Aquí tenemos los bits que conforman el número 13, con el peso
-de cada dígito mostrado debajo de el:
+de cada dígito mostrado debajo de él:
 
 ```{lang: null}
    0   0   0   0   1   1   0   1
@@ -52,16 +52,16 @@ Entonces ese es el número binario 00001101, o 8 + 4 + 1, o 13.
 {{index memory, "volatile data storage", "hard drive"}}
 
 Imagina un mar de bits—un océano de ellos. Una computadora moderna
-promedio tiene mas de 30 billones de bits en su almacenamiento de datos
+promedio tiene más de 30 billones de bits en su almacenamiento de datos
 volátiles (memoria funcional). El almacenamiento no volátil
-(disco duro o equivalente) tiende a tener unas cuantas mas ordenes de magnitud.
+(disco duro o equivalente) tiende a tener unas cuantas más órdenes de magnitud.
 
 Para poder trabajar con tales cantidades de bits sin perdernos,
 debemos separarlos en porciones que representen pedazos de información.
 En un entorno de JavaScript, esas porciones son llamadas _((valores))_.
 Aunque todos los valores están hechos de bits, estos juegan papeles diferentes.
 Cada valor tiene un ((tipo)) que determina su rol. Algunos valores son números,
-otros son pedazos de texto, otros son funciones, y asi sucesivamente.
+otros son pedazos de texto, otros son funciones, y así sucesivamente.
 
 {{index "garbage collection"}}
 
@@ -76,7 +76,7 @@ Tan pronto como dejes de utilizar un valor, este se disipará, dejando atrás
 sus bits para que estos sean reciclados como material de construcción para la
 próxima generación de valores.
 
-Este capitulo introduce los elementos atómicos de los programas en JavaScript,
+Este capítulo introduce los elementos atómicos de los programas en JavaScript,
 estos son, los tipos de valores simples y los operadores que actúan en
 tales valores.
 
@@ -93,7 +93,7 @@ En un programa hecho en JavaScript, se escriben de la siguiente manera:
 
 {{index "binary number"}}
 
-Utiliza eso en un programa, y ocasionara que el patron de bits
+Utiliza eso en un programa, y ocasionará que el patron de bits
 que representa el número 13 sea creado dentro de la memoria de la computadora.
 
 {{index [number, representation], bit}}
@@ -107,7 +107,7 @@ representados es 10^N^. Del mismo modo, dados 64 dígitos binarios, podemos
 representar 2^64^ números diferentes, lo que es alrededor de 18 mil trillones
 (un 18 con 18 ceros más). Eso es muchísimo.
 
-La memoria de un computador solía ser mucho mas pequeña que en la actualidad,
+La memoria de un computador solía ser mucho más pequeña que en la actualidad,
 y las personas tendían a utilizar grupos de 8 o 16 bits para representar sus
 números. Era común accidentalmente _((desbordar))_ esta limitación— terminando
 con un número que no cupiera dentro de la cantidad dada de bits. Hoy en día,
@@ -123,7 +123,7 @@ trillones caben en un número de JavaScript. Esos bits también almacenan
 números negativos, por lo que un bit indica el signo de un número. Un problema
 mayor es que los números no enteros tienen que ser representados también.
 Para hacer esto, algunos de los bits son usados para almacenar la posición
-del punto decimal. El número entero mas grande que puede ser
+del punto decimal. El número entero más grande que puede ser
 almacenado está en el rango de los 9 trillones (15 ceros)—lo cual es
 todavía placenteramente inmenso.
 
@@ -150,7 +150,7 @@ Eso es 2.998 × 10^8^ = 299,800,000.
 {{index pi, [number, "precision of"], "floating-point number"}}
 
 Los cálculos con números enteros (también llamados _((integer))s_)
-mas pequeños a los 9 trillones anteriormente mencionados están
+más pequeños a los 9 trillones anteriormente mencionados están
 garantizados a ser siempre precisos. Desafortunadamente, los calculos
 con números fraccionarios, generalmente no lo son. Así como π (pi) no puede
 ser precisamente expresado por un número finito de números decimales,
@@ -166,7 +166,7 @@ no como valores precisos.
 
 Lo que mayormente se hace con los números es aritmética. Operaciones aritméticas
 tales como la adición y la multiplicación, toman dos valores numéricos y
-producen un nuevo valor a raíz de ellos. Asi es como lucen en JavaScript:
+producen un nuevo valor a raíz de ellos. Así es como lucen en JavaScript:
 
 ```
 100 + 4 * 11
@@ -182,7 +182,7 @@ dos valores aplicará la operación asociada a esos valores y producirá un nuev
 
 ¿Pero el ejemplo significa "agrega 4 y 100, y multiplica el resultado por 11",
 o es la multiplicación aplicada antes de la adición? Como quizás hayas
-podido adivinar, la multiplicación sucede primero. Pero asi como en
+podido adivinar, la multiplicación sucede primero. Pero así como en
 las matemáticas, puedes cambiar este orden envolviendo la adición en paréntesis:
 
 ```
@@ -212,20 +212,20 @@ El símbolo `%` es utilizado para representar la operación de _residuo_.
 `X % Y` es el residuo de dividir `X` entre `Y`. Por ejemplo, `314 % 100`
 produce `14`, y `144 % 12` produce `0`. La precedencia del residuo es la
 la misma que la de la multiplicación y la división. Frecuentemente veras
-que este operador es tambien conocido como _modulo_.
+que este operador es también conocido como _modulo_.
 
 ### Números especiales
 
 {{index [number, "special values"]}}
 
 Existen 3 valores especiales en JavaScript que son considerados
-números pero que no se comportan como números normales.
+números, pero que no se comportan como números normales.
 
 {{index infinity}}
 
 Los primeros dos son `Infinity` y `-Infinity`, los cuales representan las
-infinidades positivas y negativas. `Infinity - 1` aun es
-`Infinity`, y asi sucesivamente. A pesar de esto, no confíes mucho
+infinidades positivas y negativas. `Infinity - 1` aún es
+`Infinity`, y así sucesivamente. A pesar de esto, no confíes mucho
 en computaciones que dependan de infinidades. Estas no son matemáticamente
 confiables, y puede que muy rápidamente nos resulten en el próximo número
 especial: `NaN`.
@@ -262,33 +262,33 @@ y al final coincidan.
 {{index "line break", "newline character"}}
 
 Casi todo puede ser colocado entre comillas, y JavaScript construirá
-un valor string a partir de ello. Pero algunos caracteres son mas difíciles.
+un valor string a partir de ello. Pero algunos carácteres son más difíciles.
 Te puedes imaginar que colocar comillas entre comillas podría ser difícil.
-Los _Newlines_ (los caracteres que obtienes cuando presionas la tecla de Enter)
+Los _Newlines_ (los carácteres que obtienes cuando presionas la tecla de Enter)
 solo pueden ser incluidos cuando el string está encapsulado con comillas
 invertidas (`` ` ``).
 
 {{index [escaping, "in strings"], "backslash character"}}
 
-Para hacer posible incluir tales caracteres en un string, la siguiente
+Para hacer posible incluir tales carácteres en un string, la siguiente
 notación es utilizada: cuando una barra invertida (`\`) es encontrada dentro de
 un texto entre comillas, indica que el carácter que le sigue tiene un
 significado especial. Esto se conoce como _escapar_ el carácter.
 Una comilla que es precedida por una barra invertida no representará
 el final del string sino que formara parte del mismo. Cuando el
 carácter `n` es precedido por una barra invertida, este se interpreta
-como un Newline (salto de linea). De la mima forma, `t` después de una barra
+como un Newline (salto de línea). De la mima forma, `t` después de una barra
 invertida, se interpreta como un character de tabulación.
 Toma como referencia el siguiente string:
 
 ```
-"Esta es la primera linea\nY esta es la segunda"
+"Esta es la primera línea\nY esta es la segunda"
 ```
 
 El texto actual es este:
 
 ```{lang: null}
-Esta es la primera linea
+Esta es la primera línea
 Y esta es la segunda
 ```
 
@@ -296,11 +296,11 @@ Se encuentran, por supuesto, situaciones donde queremos que una barra
 invertida en un string solo sea una barra invertida, y no un carácter
 especial. Si dos barras invertidas prosiguen una a la otra, serán
 colapsadas y sólo una permanecerá en el valor resultante del string.
-Asi es como el string "_Un carácter de salto de linea es escrito
+Así es como el string "_Un carácter de salto de línea es escrito
 así: `"`\n`"`._" puede ser expresado:
 
 ```
-Un carácter de salto de linea es escrito así: \"\\n\"."
+Un carácter de salto de línea es escrito así: \"\\n\"."
 ```
 
 {{id unicode}}
@@ -310,8 +310,8 @@ Un carácter de salto de linea es escrito así: \"\\n\"."
 También los strings deben de ser modelados como una serie de bits para poder
 existir dentro del computador. La forma en la que JavaScript hace esto
 es basada en el estándar _((Unicode))_. Este estándar asigna un número a
-todo carácter que alguna vez pudieras necesitar, incluyendo caracteres en
-Griego, Árabe, Japones, Armenio, y asi sucesivamente. Si tenemos un número para
+todo carácter que alguna vez pudieras necesitar, incluyendo carácteres en
+Griego, Árabe, Japones, Armenio, y así sucesivamente. Si tenemos un número para
 representar cada carácter, un string puede ser descrito como una
 secuencia de números.
 
@@ -319,11 +319,11 @@ secuencia de números.
 
 Y eso es lo que hace JavaScript. Pero hay una complicación:
 La representación de JavaScript usa 16 bits por cada elemento string, en
-el cual caben 2^16^ números diferentes. Pero Unicode define mas caracteres
+el cual caben 2^16^ números diferentes. Pero Unicode define más carácteres
 que aquellos—aproximadamente el doble, en este momento.
-Entonces algunos caracteres, como muchos emojis, necesitan ocupar dos
-"posiciones de caracteres" en los strings de JavaScript. Volveremos a este
-tema en el [Capitulo 5](orden_superior#unidades_de_codigo).
+Entonces algunos carácteres, como muchos emojis, necesitan ocupar dos
+"posiciones de carácteres" en los strings de JavaScript. Volveremos a este
+tema en el [Capítulo 5](orden_superior#unidades_de_codigo).
 
 {{index "+ operator", concatenation}}
 
@@ -343,10 +343,10 @@ a estas en el [Capítulo 4](datos#metodos).
 {{index interpolation, backtick}}
 
 Los strings escritos con comillas simples o dobles se comportan
-casi de la misma manera—La unica diferencia es el tipo de comilla que necesitamos
+casi de la misma manera—La única diferencia es el tipo de comilla que necesitamos
 para escapar dentro de ellos. Los strings de comillas inversas, usualmente
 llamados _((plantillas literales))_, pueden realizar algunos trucos
-más. Mas alla de permitir saltos de lineas, pueden también incrustar otros
+más. Más allá de permitir saltos de líneas, pueden también incrustar otros
 valores.
 
 ```
@@ -361,7 +361,7 @@ posición. El ejemplo anterior produce "_la mitad de 100 es 50_".
 
 {{index operator, "typeof operator", type}}
 
-No todo los operadores son simbolos. Algunos se escriben como palabras.
+No todo los operadores son símbolos. Algunos se escriben como palabras.
 Un ejemplo es el operador `typeof`, que produce un string con el nombre
 del tipo de valor que le demos.
 
@@ -378,12 +378,12 @@ console.log(typeof "x")
 
 Usaremos `console.log` en los ejemplos de código para indicar que
 que queremos ver el resultado de alguna evaluación.
-Mas acerca de esto esto en el [proximo capitulo](estructura_de_programa).
+Más acerca de esto esto en el [próximo capítulo](estructura_de_programa).
 
 {{index negation, "- operator", "binary operator", "unary operator"}}
 
 En los otros operadores que hemos visto hasta ahora, todos operaban en
-dos valores, pero `typeof` sola opera con un valor. Los operadores que usan
+dos valores, pero `typeof` solo opera con un valor. Los operadores que usan
 dos valores son llamados operadores _binarios_, mientras que aquellos
 operadores que usan uno son llamados operadores _unarios_. El operador menos
 puede ser usado tanto como un operador binario o como un operador unario.
@@ -397,7 +397,7 @@ console.log(- (10 - 2))
 
 {{index Boolean, operator, true, false, bit}}
 
-Es frecuentemente util tener un valor que distingue entre solo dos
+Es frecuentemente útil tener un valor que distingue entre solo dos
 posibilidades, como "si", y "no", o "encendido" y "apagado". Para este
 propósito, JavaScript tiene el tipo _Boolean_, que tiene solo dos valores:
 true (verdadero) y false (falso) que se escriben de la misma forma.
@@ -434,9 +434,9 @@ console.log("Aardvark" < "Zoroaster")
 La forma en la que los strings son ordenados, es aproximadamente alfabético,
 aunque no realmente de la misma forma que esperaríamos ver en un diccionario:
 las letras mayúsculas son siempre "menores que" las letras minúsculas, así que
-`"Z" < "a"`, y caracteres no alfabéticos (como `!`, `-` y demás) son también
+`"Z" < "a"`, y carácteres no alfabéticos (como `!`, `-` y demás) son también
 incluidos en el ordenamiento. Cuando comparamos strings, JavaScript evalúa
-los caracteres  de izquierda a derecha, comparando los códigos ((Unicode))
+los carácteres  de izquierda a derecha, comparando los códigos ((Unicode))
 uno por uno.
 
 {{index equality, ">= operator", "<= operator", "== operator", "!= operator"}}
@@ -520,7 +520,7 @@ posible sea necesaria:
 
 {{index "conditional execution", "ternary operator", "?: operator", "conditional operator", "colon character", "question mark"}}
 
-El ultimo operador lógico que discutiremos no es unario, tampoco binario,
+El último operador lógico que discutiremos no es unario, tampoco binario,
 sino _ternario_, esto es, que opera en tres valores. Es escrito con un
 signo de interrogación y dos puntos, de esta forma:
 
@@ -546,7 +546,7 @@ usados para denotar la ausencia de un valor _significativo_. Son en si mismos
 valores, pero no traen consigo información.
 
 Muchas operaciones en el lenguaje que no producen un valor significativo
-(veremos algunas mas adelante), producen `undefined` simplemente porque tienen
+(veremos algunas más adelante), producen `undefined` simplemente porque tienen
 que producir _algún_ valor.
 
 La diferencia en significado entre `undefined` y `null` es un accidente del
@@ -558,7 +558,7 @@ mayormente recomiendo que los trates como intercambiables.
 
 {{index NaN, "type coercion"}}
 
-En la Introducción, mencione que JavaScript tiende a salirse de su camino para
+En la Introducción, mencioné que JavaScript tiende a salirse de su camino para
 aceptar casi cualquier programa que le demos, incluso programas que hacen cosas
 extrañas. Esto es bien demostrado por las siguientes expresiones:
 
@@ -591,7 +591,7 @@ numérica, entonces el `1` es convertido a `"1"` (de número a string)
 Cuando algo que no se traduce a un número en una manera obvia (tal como
 `"cinco"` o `undefined`) es convertido a un número, obtenemos el valor
 `NaN`. Operaciones aritméticas subsecuentes con `NaN`, continúan
-produciendo `NaN`, asi que si te encuentras obteniendo uno de estos
+produciendo `NaN`, así que si te encuentras obteniendo uno de estos
 valores en algun lugar inesperado, busca por coerciones de tipo accidentales.
 
 {{index null, undefined, [comparison, "of undefined values"], "== operator"}}
@@ -612,7 +612,7 @@ console.log(null == 0);
 // → false
 ```
 
-Este comportamiento es frecuentemente util. Cuando queremos probar
+Este comportamiento es frecuentemente útil. Cuando queremos probar
 si un valor tiene un valor real en vez de `null` o `undefined`, puedes
 compararlo con `null` usando el operador `==` (o `!=`).
 
@@ -623,15 +623,15 @@ al valor `false`? Las reglas para convertir strings y números a valores
 Booleanos, dice que `0`, `NaN`, y el string vació (`""`) cuentan como `false`,
 mientras que todos los otros valores cuentan como `true`. Debido a esto,
 expresiones como `0 == false`, y `"" == false` son también verdaderas.
-Cuando no queremos ninguna conversion de tipo automática, existen otros
+Cuando no queremos ninguna conversión de tipo automática, existen otros
 dos operadores adicionales: `===` y `!==`. El primero prueba si un valor
 es _precisamente_ igual al otro, y el segundo prueba si un valor no es
 precisamente igual. Entonces `"" === false` es falso, como es de esperarse.
 
-Recomiendo usar el operador de comparación de tres caracteres de una manera
+Recomiendo usar el operador de comparación de tres carácteres de una manera
 defensiva para prevenir que conversiones de tipo inesperadas te estorben.
 Pero cuando estés seguro de que el tipo va a ser el mismo en ambos lados, no es
-problemático utilizar los operadores mas cortos.
+problemático utilizar los operadores más cortos.
 
 ### Corto circuito de operadores lógicos
 
@@ -663,7 +663,7 @@ console.log("Agnes" || "usuario")
 Podemos utilizar esta funcionalidad como una forma de recurrir a
 un valor por defecto. Si tenemos un valor que puede estar vacío,
 podemos usar `||` después de este para remplazarlo con otro valor.
-Si el valor inicial puede ser convertido a falso, obtendra el
+Si el valor inicial puede ser convertido a falso, obtendrá el
 reemplazo en su lugar.
 
 {{index "&& operator"}}
@@ -674,7 +674,7 @@ ese valor, y de lo contrario, devuelve el valor a su derecha.
 
 Otra propiedad importante de estos dos operadores es que la parte
 de su derecha solo es evaluada si es necesario. En el caso de
-de `true || X`, no importa que sea `X`—aun si es una pieza del programa
+de `true || X`, no importa que sea `X`—aún si es una pieza del programa
 que hace algo _terrible_—el resultado será verdadero, y `X` nunca
 sera evaluado. Lo mismo sucede con `false && X`, que es falso e ignorará
 `X`. Esto es llamado _((evaluación de corto circuito))_.
@@ -700,5 +700,5 @@ ternario (`?:`) para elegir uno de dos valores basándose en un tercer valor.
 
 Esto te dá la información suficiente para usar JavaScript como una
 calculadora de bolsillo, pero no para mucho más. El [próximo
-capitulo](estructura_de_programa) empezará a juntar estas expresiones
+capítulo](estructura_de_programa) empezará a juntar estas expresiones
 para formar programas básicos.
diff --git a/02_program_structure.md b/02_program_structure.md
index 6210df4ef..b88ef9228 100644
--- a/02_program_structure.md
+++ b/02_program_structure.md
@@ -78,8 +78,8 @@ En algunos casos, JavaScript te permite omitir el punto y coma al final
 de una declaración. En otros casos, tiene que estar allí, o la próxima
 ((línea)) serán tratada como parte de la misma declaración. Las reglas para
 saber cuando se puede omitir con seguridad son algo complejas y propensas a
-errores. Asi que en este libro, cada declaración que necesite un punto y coma
-siempre tendra uno. Te recomiendo que hagas lo mismo, al menos hasta que hayas
+errores. Así que en este libro, cada declaración que necesite un punto y coma
+siempre tendrá uno. Te recomiendo que hagas lo mismo, al menos hasta que hayas
 aprendido más sobre las sutilezas de los puntos y comas que puedan ser
 omitidos.
 
@@ -88,7 +88,7 @@ omitidos.
 {{indexsee variable, binding}}
 {{index syntax, [binding, definition], "side effect", memory}}
 
-Cómo mantiene un programa un ((estado)) interno? Cómo recuerda
+¿Cómo mantiene un programa un ((estado)) interno? ¿Cómo recuerda
 cosas? Hasta ahora hemos visto cómo producir nuevos valores a partir de
 valores anteriores, pero esto no cambia los valores anteriores, y el nuevo valor
 tiene que ser usado inmediatamente o se disipará nuevamente. Para atrapar y
@@ -233,7 +233,7 @@ palabra reservada.
 {{index "standard environment"}}
 
 La colección de vinculaciones y sus valores que existen en un momento dado
-se llama _((entorno))_. Cuando se inicia un programa, est
+se llama _((entorno))_. Cuando se inicia un programa, este 
 entorno no está vacío. Siempre contiene vinculaciones que son parte del
 ((estándar)) del lenguaje, y la mayoría de las veces, también tiene vinculaciones
 que proporcionan formas de interactuar con el sistema circundante. Por
@@ -251,7 +251,7 @@ Muchos de los valores proporcionados por el entorno predeterminado tienen el
 tipo _((función))_. Una función es una pieza de programa envuelta en un valor.
 Dichos valores pueden ser _aplicados_ para ejecutar el programa envuelto. Por
 ejemplo, en un entorno ((navegador)), la vinculación `prompt` sostiene una
-función que muestra un pequeño ((cuadro de diálogo)) preguntando por entrada
+función que muestra un pequeño ((cuadro de diálogo)) preguntando por la entrada
 del usuario. Esta se usa así:
 
 ```
@@ -262,9 +262,9 @@ prompt("Introducir contraseña");
 
 {{index parameter, [function, application]}}
 
-Ejecutar una función tambien se conoce como _invocarla_, _llamarla_, o
+Ejecutar una función también se conoce como _invocarla_, _llamarla_, o
 _aplicarla_. Puedes llamar a una función poniendo ((paréntesis)) después de una
-expresión que produzca un valor de función. Usualmente usarás directamente
+expresión que produzca un valor de función. De normal usarás directamente
 el nombre de la vinculación que contenga la función. Los valores entre
 los paréntesis se dan al programa dentro de la función. En el
 ejemplo, la función `prompt` usa el string que le damos como el
@@ -281,7 +281,7 @@ diálogo resultante, pero puede ser útil en programas de juguete y experimentos
 {{index "JavaScript console", "developer tools", "Node.js", "console.log", output}}
 
 En los ejemplos, utilicé `console.log` para dar salida a los valores.
-La mayoría de los sistemas de JavaScript (incluidos todos los ((navegadore))s
+La mayoría de los sistemas de JavaScript (incluídos todos los ((navegadore))s
 web modernos y Node.js) proporcionan una función `console.log` que escribe
 sus argumentos en _algun_ dispositivo de salida de texto. En los navegadores,
 esta salida aterriza en la ((consola de JavaScript)). Esta parte de la interfaz
@@ -307,7 +307,7 @@ if}}
 {{index object}}
 
 Aunque los nombres de las vinculaciones no puedan contener
-((carácteres de punto))s, `console.log` tiene uno. Esto es porque `console.log`
+((caracteres de punto))s, `console.log` tiene uno. Esto es porque `console.log`
 no es un vinculación simple. En realidad, es una expresión que obtiene la
 ((propiedad)) `log` del valor mantenido por la vinculación `console`.
 Averiguaremos qué significa esto exactamente en el
@@ -366,7 +366,7 @@ console.log("Tu número es la raiz cuadrada de " +
 
 La función `Número` convierte un valor a un número. Necesitamos esa
 conversión porque el resultado de `prompt` es un valor de string, y nosotros
-queremos un numero. Hay funciones similares llamadas `String` y
+queremos un número. Hay funciones similares llamadas `String` y
 `Boolean` que convierten valores a esos tipos.
 
 Aquí está la representación esquemática (bastante trivial) de un flujo de
@@ -380,7 +380,7 @@ control en línea recta:
 
 No todos los programas son caminos rectos. Podemos, por ejemplo, querer
 crear un camino de ramificación, donde el programa toma la rama adecuada
-basadandose en la situación en cuestión. Esto se llama _((ejecución
+basádandose en la situación en cuestión. Esto se llama _((ejecución
 condicional))_.
 
 {{figure {url: "img/controlflow-if.svg", alt: "Conditional control flow",width: "4cm"}}}
@@ -393,9 +393,9 @@ una cierta condición se cumple. Podríamos, por ejemplo, solo querer mostrar el
 cuadrado de la entrada si la entrada es realmente un número.
 
 ```{test: wrap}
-let elNumero = Number(prompt("Elige un numero"));
+let elNumero = Number(prompt("Elige un número"));
 if (!Number.isNaN(elNumero)) {
-  console.log("Tu número es la raiz cuadrada de " +
+  console.log("Tu número es la raíz cuadrada de " +
               elNumero * elNumero);
 }
 ```
@@ -425,8 +425,8 @@ también haberlas omitido en este caso, ya que solo tienes una sola
 declaración, pero para evitar tener que pensar si se necesitan
 o no, la mayoría de los programadores en JavaScript las usan en cada una
 de sus declaraciones envueltas como esta. Seguiremos esta convención
-en la mayoria de este libro, a excepción de la ocasional declaración
-de una sola linea.
+en la mayoría de este libro, a excepción de la ocasional declaración
+de una sola línea.
 
 ```
 if (1 + 1 == 2) console.log("Es verdad");
@@ -442,12 +442,12 @@ se puede usar, junto con `if`, para crear dos caminos de ejecución
 alternativos, de una manera separada.
 
 ```{test: wrap}
-let elNumero = Number(prompt("Elige un numero"));
+let elNumero = Number(prompt("Elige un número"));
 if (!Number.isNaN(elNumero)) {
-  console.log("Tu número es la raiz cuadrada de " +
+  console.log("Tu número es la raíz cuadrada de " +
               elNumero * elNumero);
 } else {
-  console.log("Ey. Por qué no me diste un número?");
+  console.log("Ey ¿Por qué no me diste un número?");
 }
 ```
 
@@ -457,7 +457,7 @@ Si tenemos más de dos rutas a elegir, múltiples pares de `if`/`else`
 se pueden "encadenar". Aquí hay un ejemplo:
 
 ```
-let numero = Number(prompt("Elige un numero"));
+let numero = Number(prompt("Elige un número"));
 
 if (numero < 10) {
   console.log("Pequeño");
@@ -574,7 +574,7 @@ del ciclo:
 ```
 let tuNombre;
 do {
-  tuNombre = prompt("Quien eres?");
+  tuNombre = prompt("¿Quién eres?");
 } while (!tuNombre);
 console.log(tuNombre);
 ```
@@ -595,7 +595,7 @@ En los ejemplos, he estado agregando espacios adelante de declaraciones que
 son parte de una declaración más grande. Estos no son necesarios—la computadora
 aceptará el programa normalmente sin ellos. De hecho, incluso las nuevas
 ((líneas)) en los programas son opcionales. Podrías escribir un
-programa en una sola línea inmensa si asi quisieras.
+programa en una sola línea inmensa si así quisieras.
 
 El rol de esta ((indentación)) dentro de los ((bloques)) es hacer que
 la estructura del código se destaque. En código donde se abren nuevos bloques
@@ -604,14 +604,14 @@ y donde comienza el otro. Con la indentación apropiada, la forma visual de un
 programa corresponde a la forma de los bloques dentro de él. Me gusta
 usar dos espacios para cada bloque abierto, pero los gustos varían—algunas
 personas usan cuatro espacios, y algunas personas usan
-((carácteres de tabulación)). Lo cosa importante es que cada bloque
+((caracteres de tabulación)). Lo cosa importante es que cada bloque
 nuevo agregue la misma cantidad de espacio.
 
 ```
 if (false != true) {
   console.log("Esto tiene sentido.");
   if (1 < 2) {
-    console.log("Ninguna sorpresa alli.");
+    console.log("Ninguna sorpresa allí.");
   }
 }
 ```
@@ -653,7 +653,7 @@ con el "estado" del ciclo estan agrupadas después del `for`.
 
 Los ((paréntesis)) después de una palabra clave `for` deben contener dos
 ((punto y coma))s. La parte antes del primer punto y coma _inicializa_ el
-cicloe, generalmente definiendo una ((vinculación)). La segunda parte es la
+ciclo, generalmente definiendo una ((vinculación)). La segunda parte es la
 ((expresión)) que _chequea_ si el ciclo debe continuar. La parte final
 _actualiza_ el estado del ciclo después de cada iteración. En la mayoría de
 los casos, esto es más corto y conciso que un constructo `while`.
@@ -779,21 +779,21 @@ else accionPorDefault();
 Existe un constructo llamado `switch` que está destinada a expresar tales
 "despachos" de una manera más directa. Desafortunadamente, la sintaxis que
 JavaScript usa para esto (que heredó de la línea lenguajes de programación
-C/Java) es algo incómoda—una cadena de declaraciones `if` podria llegar a verse
+C/Java) es algo incómoda—una cadena de declaraciones `if` podría llegar a verse
 mejor. Aquí hay un ejemplo:
 
 ```
-switch (prompt("Como esta el clima?")) {
+switch (prompt("¿Cómo está el clima?")) {
   case "lluvioso":
     console.log("Recuerda salir con un paraguas.");
     break;
   case "soleado":
-    console.log("Vistete con poca ropa.");
+    console.log("Vístete con poca ropa.");
   case "nublado":
     console.log("Ve afuera.");
     break;
   default:
-    console.log("Tipo de clima desconocido!");
+    console.log("¡Tipo de clima desconocido!");
     break;
 }
 ```
@@ -905,7 +905,7 @@ flujo de control usando declaraciones condicionales (`if`, `else`, y `switch`)
 y ciclos (`while`, `do`, y `for`).
 
 Las vinculaciones se pueden usar para archivar datos bajo un nombre, y son
-utiles para el seguimiento de estado en tu programa. El entorno es el conjunto
+útiles para el seguimiento de estado en tu programa. El entorno es el conjunto
 de vinculaciones que se definen. Los sistemas de JavaScript siempre
 incluyen por defecto un número de vinculaciones estándar útiles en tu entorno.
 
@@ -917,7 +917,7 @@ llamada a función es una expresión, y puede producir un valor.
 
 {{index exercises}}
 
-Si no estas seguro de cómo probar tus soluciones para los ejercicios, consulta
+Si no estás seguro de cómo probar tus soluciones para los ejercicios, consulta
 la [introducción](intro).
 
 Cada ejercicio comienza con una descripción del problema. Lee eso y trata de
@@ -927,7 +927,7 @@ resolver el ejercicio. Si tienes problemas, considera leer las pistas
 ejercicios no estan incluidas en este libro, pero puedes encontrarlas en línea
 en [_eloquentjavascript.net/code_](https://eloquentjavascript.net/code#2).
 Si quieres aprender algo de los ejercicios, te recomiendo mirar a las
-soluciones solo despues de que hayas resuelto el ejercicio, o al menos despues
+soluciones solo después de que hayas resuelto el ejercicio, o al menos después
 de que lo hayas intentando resolver por un largo tiempo y tengas un
 ligero dolor de cabeza.
 
@@ -935,7 +935,7 @@ ligero dolor de cabeza.
 
 {{index "triangle (exercise)"}}
 
-Escriba un ((ciclo)) que haga siete llamadas a `console.log` para generar el
+Escribe un ((ciclo)) que haga siete llamadas a `console.log` para generar el
 siguiente triángulo:
 
 ```{lang: null}
@@ -966,7 +966,7 @@ modificar para resolver el ejercicio. Recuerda que puedes hacer clic en los
 bloques de código para editarlos.
 
 ```
-// Tu código aqui.
+// Tu código aquí.
 ```
 if}}
 
diff --git a/03_functions.md b/03_functions.md
index a9812775e..e396190c8 100644
--- a/03_functions.md
+++ b/03_functions.md
@@ -129,7 +129,7 @@ mucho acerca de lo qué está pasando en el entorno global.
 {{index "let keyword", "const keyword", "var keyword"}}
 
 Vinculaciones declaradas con `let` y `const` son, de hecho, locales al
-_((bloque))_ donde esten declarados, así que si creas uno de esas
+_((bloque))_ donde estén declarados, así que si creas uno de esas
 dentro de un ciclo, el código antes y después del ciclo no puede "verlas".
 En JavaScript anterior a 2015, solo las funciones creaban nuevos alcances,
 por lo que las vinculaciones de estilo-antiguo, creadas con la palabra clave
@@ -144,7 +144,7 @@ if (true) {
   console.log(x + y + z);
   // → 60
 }
-// y no es visible desde aqui
+// y no es visible desde aquí
 console.log(x + z);
 // → 40
 ```
@@ -212,7 +212,7 @@ de la función externa. Pero sus vinculaciones locales, como `unidad` o
 En resumen, cada alcance local puede ver también todos los alcances locales que
 lo contengan. El conjunto de vinculaciones visibles dentro de un bloque
 está determinado por el lugar de ese bloque en el texto del programa.
-Cada alcance local puede tambien ver todos los alcances locales que lo
+Cada alcance local puede también ver todos los alcances locales que lo
 contengan, y todos los alcances pueden ver el alcance global.
 Este enfoque para la visibilidad de vinculaciones es
 llamado _((alcance léxico))_.
@@ -245,7 +245,7 @@ if (modoSeguro) {
 
 {{index [function, "higher-order"]}}
 
-En el [Capitulo 5](orden_superior), discutiremos las cosas interesantes
+En el [Capítulo 5](orden_superior), discutiremos las cosas interesantes
 que se pueden hacer al pasar valores de función a otras funciones.
 
 ## Notación de declaración
@@ -265,7 +265,7 @@ function cuadrado(x) {
 {{index future, "execution order"}}
 
 Esta es una _declaración_ de función. La declaración define la vinculación
-`cuadrado` y la apunta a la función dada. Esto es un poco mas facil
+`cuadrado` y la apunta a la función dada. Esto es un poco más fácil
 de escribir, y no requiere un punto y coma después de la función.
 
 Hay una sutileza con esta forma de definir una función.
@@ -274,7 +274,7 @@ Hay una sutileza con esta forma de definir una función.
 console.log("El futuro dice:", futuro());
 
 function futuro() {
-  return "Nunca tendran autos voladores";
+  return "Nunca tendrán autos voladores";
 }
 ```
 
@@ -317,7 +317,7 @@ el cuerpo de la función. Expresa algo así como "esta entrada (los
 Cuando solo haya un solo nombre de parámetro, los ((paréntesis)) alrededor de
 la lista de parámetros pueden ser omitidos. Si el cuerpo es una sola expresión,
 en lugar de un ((bloque)) en llaves, esa expresión será retornada por parte
-de la función. Asi que estas dos definiciones de `cuadrado` hacen la misma
+de la función. Así que estas dos definiciones de `cuadrado` hacen la misma
 cosa:
 
 ```
@@ -341,7 +341,7 @@ expresiones `function` en el lenguaje. Aparte de un detalle menor,
 que discutiremos en [Capítulo 6](objeto), estas hacen lo mismo.
 Las funciones de flecha se agregaron en 2015, principalmente para que fuera
 posible escribir pequeñas expresiones de funciones de una manera menos
-verbosa. Las usaremos mucho en el [Capitulo 5](orden_superior).
+verbosa. Las usaremos mucho en el [Capítulo 5](orden_superior).
 
 {{id stack}}
 
@@ -351,7 +351,7 @@ verbosa. Las usaremos mucho en el [Capitulo 5](orden_superior).
 {{index "call stack", [function, application]}}
 
 La forma en que el control fluye a través de las funciones es algo
-complicado. Vamos a écharle un vistazo más de cerca. Aquí hay un simple
+complicado. Vamos a echarle un vistazo más de cerca. Aquí hay un simple
 programa que hace unas cuantas llamadas de función:
 
 ```
@@ -359,7 +359,7 @@ function saludar(quien) {
   console.log("Hola " + quien);
 }
 saludar("Harry");
-console.log("Adios");
+console.log("Adiós");
 ```
 
 {{index "control flow", "execution order", "console.log"}}
@@ -374,8 +374,6 @@ que esta función retorna, el programa llega a su fin.
 
 Podríamos mostrar el flujo de control esquemáticamente de esta manera:
 
-We could show the flow of control schematically like this:
-
 ```{lang: null}
 no en una función
    en saludar
@@ -405,7 +403,7 @@ Almacenar esta pila requiere espacio en la memoria de la computadora. Cuando
 la pila crece demasiado grande, la computadora fallará con un mensaje como
 "fuera de espacio de pila" o "demasiada recursividad". El siguiente código
 ilustra esto haciendo una pregunta realmente difícil a la computadora, que
-causara un ir y venir infinito entre las dos funciones. Mejor dicho,
+causará un ir y venir infinito entre las dos funciones. Mejor dicho,
 _sería_ infinito, si la computadora tuviera una pila infinita. Como son
 las cosas, nos quedaremos sin espacio, o "explotaremos la pila".
 
@@ -450,7 +448,7 @@ Y nadie te dira nada acerca de eso.
 La ventaja es que este comportamiento se puede usar para permitir que
 una función sea llamada con diferentes cantidades de argumentos. Por ejemplo,
 esta función `menos` intenta imitar al operador `-` actuando ya sea en uno o
-dos argumentos
+dos argumentos:
 
 ```
 function menos(a, b) {
@@ -497,7 +495,7 @@ En el [próximo capítulo](datos#parametros_rest), veremos una forma en el
 que el cuerpo de una función puede obtener una lista de todos los argumentos
 que son pasados. Esto es útil porque hace posible que una función
 acepte cualquier cantidad de argumentos. Por ejemplo, `console.log` hace
-esto—muetra en la consola todos los valores que se le den.
+esto—muestra en la consola todos los valores que se le den.
 
 ```
 console.log("C", "O", 2);
@@ -510,7 +508,7 @@ console.log("C", "O", 2);
 
 La capacidad de tratar a las funciones como valores, combinado con el hecho de
 que las vinculaciones locales se vuelven a crear cada vez que una sea función
-es llamada, trae a la luz una pregunta interesante. Qué sucede con las
+es llamada, trae a la luz una pregunta interesante. ¿Qué sucede con las
 vinculaciones locales cuando la llamada de función que los creó ya no
 está activa?
 
@@ -540,10 +538,10 @@ distintas vinculaciones locales entre sí.
 
 Esta característica—poder hacer referencia a una instancia específica
 de una vinculación local en un alcance encerrado—se llama _((cierre))_.
-Una función que que hace referencia a vinculaciones de alcances locales
+Una función que hace referencia a vinculaciones de alcances locales
 alrededor de ella es llamada _un_ cierre.
 Este comportamiento no solo te libera de tener que preocuparte
-por la duración de las vinculaciones pero también hace posible usar valores de
+por la duración de las vinculaciones sino que también hace posible usar valores de
 funciones en algunas formas bastante creativas.
 
 {{index "multiplier function"}}
@@ -620,8 +618,8 @@ terminos de memoria que llamar a una función multiples veces.
 
 El dilema de velocidad versus ((elegancia)) es interesante.
 Puedes verlo como una especie de compromiso entre accesibilidad-humana y
-accesibilidad-maquina. Casi cualquier programa se puede hacer más
-rápido haciendolo más grande y complicado. El programador tiene que
+accesibilidad-máquina. Casi cualquier programa se puede hacer más
+rápido haciéndolo más grande y complicado. El programador tiene que
 decidir acerca de cual es un equilibrio apropiado.
 
 En el caso de la función `potencia`, la versión poco elegante (con el ciclo)
@@ -688,7 +686,7 @@ console.log(encontrarSolucion(24));
 ```
 
 Ten en cuenta que este programa no necesariamente encuentra la secuencia de
-operaciones _mas corta_. Este está satisfecho cuando encuentra cualquier
+operaciones _más corta_. Este está satisfecho cuando encuentra cualquier
 secuencia que funcione.
 
 Está bien si no ves cómo funciona el programa de inmediato. Vamos a trabajar
@@ -737,10 +735,10 @@ encontrar(1, "1")
 ```
 
 La indentación indica la profundidad de la pila de llamadas. La primera vez
-que `encontrar` es llamada, comienza llamandose a sí misma para explorar
-la solución que comienza con `(1 + 5)`. Esa llamada hara uso de la recursión
+que `encontrar` es llamada, comienza llamándose a sí misma para explorar
+la solución que comienza con `(1 + 5)`. Esa llamada hará uso de la recursión
 aún más para explorar _cada_ solución continuada que produzca un número menor
-o igual a el número objetivo. Como no encuentra uno que llegue al objetivo,
+o igual al número objetivo. Como no encuentra uno que llegue al objetivo,
 retorna `null` a la primera llamada. Ahí el operador `||` genera la llamada
 que explora `(1 * 3)` para que esta suceda. Esta búsqueda tiene más
 suerte—su primera llamada recursiva, a través de _otra_ llamada recursiva,
@@ -812,9 +810,9 @@ Escribir `.length` después de una expresión de string nos dará la longitud de
 dicho string. Por lo tanto, los ciclos `while` seguiran sumando ceros delante
 del string de numeros hasta que este tenga al menos tres caracteres de longitud.
 
-Misión cumplida! Pero justo cuando estamos por enviar el código a la
+¡Misión cumplida! Pero justo cuando estamos por enviar el código a la
 agricultora (junto con una considerable factura), ella nos llama y nos dice
-que ella también comenzó a criar cerdos, y que si no podríamos extender
+que ella también comenzó a criar cerdos, y que si ¿No podríamos extender
 el software para imprimir cerdos también?
 
 {{index "copy-paste programming"}}
@@ -843,7 +841,7 @@ imprimirInventarioGranja(7, 11, 3);
 
 {{index [function, naming]}}
 
-Funciona! Pero ese nombre, `imprimirEtiquetaAlcochadaConCeros`, es un poco
+¡Funciona! Pero ese nombre, `imprimirEtiquetaAlcochadaConCeros`, es un poco
 incómodo. Combina tres cosas—impresión, alcochar con ceros y añadir
 una etiqueta—en una sola función.
 
@@ -880,7 +878,7 @@ números en una manera alineada.
 
 {{index [interface, design]}}
 
-Que tan inteligente y versátil _deberia_ de ser nuestra función? Podríamos
+¿Qué tan inteligente y versátil _deberia_ de ser nuestra función? Podríamos
 escribir cualquier cosa, desde una función terriblemente simple que solo
 pueda alcochar un número para que tenga tres caracteres de ancho,
 a un complicado sistema generalizado de formateo de números que maneje
@@ -916,7 +914,7 @@ secundarios.
 {{index substitution}}
 
 Una función _pura_ es un tipo específico de función de producción-de-valores
-que no solo no tiene efectos secundarios pero que tampoco depende de los
+que no solo no tiene efectos secundarios sino que tampoco depende de los
 efectos secundarios de otro código—por ejemplo, no lee vinculaciones globales
 cuyos valores puedan cambiar. Una función pura tiene la propiedad agradable
 de que cuando se le llama con los mismos argumentos, siempre produce el
@@ -967,7 +965,7 @@ Vinculaciones declaradas con `var` se comportan de manera
 diferente—terminan en el alcance de la función más cercana o en el alcance global.
 
 Separar las tareas que realiza tu programa en diferentes funciones es
-util. No tendrás que repetirte tanto, y las funciones pueden
+útil. No tendrás que repetirte tanto, y las funciones pueden
 ayudar a organizar un programa agrupando el código en piezas que hagan
 cosas especificas.
 
@@ -985,7 +983,7 @@ dos argumentos y retorne su mínimo.
 {{if interactive
 
 ```{test: no}
-// Tu codigo aqui.
+// Tu código aquí.
 
 console.log(min(0, 10));
 // → 0
@@ -1029,13 +1027,13 @@ número entero, positivo) y devolver un Booleano.
 
 {{index "stack overflow"}}
 
-Pruébalo con 50 y 75. Observa cómo se comporta con -1. Por qué?
-Puedes pensar en una forma de arreglar esto?
+Pruébalo con 50 y 75. Observa cómo se comporta con -1. ¿Por qué?
+¿Puedes pensar en una forma de arreglar esto?
 
 {{if interactive
 
 ```{test: no}
-// Tu codigo aqui.
+// Tu código aquí.
 
 console.log(esPar(50));
 // → true
@@ -1084,7 +1082,7 @@ Escribe una función `contarFs` que tome un string como su único argumento
 y devuelva un número que indica cuántos caracteres "F" en mayúsculas
 haya en el string.
 
-Despues, escribe una función llamada `contarCaracteres` que se comporte
+Después, escribe una función llamada `contarCaracteres` que se comporte
 como `contarFs`, excepto que toma un segundo argumento que indica el carácter
 que debe ser contado (en lugar de contar solo caracteres "F" en mayúscula).
 Reescribe `contarFs` para que haga uso de esta nueva función.
diff --git a/04_data.md b/04_data.md
index f1170af6b..ac38bcb76 100644
--- a/04_data.md
+++ b/04_data.md
@@ -4,7 +4,7 @@
 
 {{quote {author: "Charles Babbage", title: "Passages from the Life of a Philosopher (1864)", chapter: true}
 
-En dos ocasiones me han preguntado, 'Dinos, Sr. Babbage, si pones
+En dos ocasiones me han preguntado, 'Dinos, Sr. Babbage, ¿si pones
 montos equivocadas en la máquina, saldrán las respuestas correctas?
 [...] No soy capaz de comprender correctamente el tipo de confusión de
 ideas que podrían provocar tal pregunta.
@@ -24,10 +24,10 @@ otros objetos— para construir estructuras más complejas.
 
 Los programas que hemos construido hasta ahora han estado limitados por el
 hecho de que estaban operando solo en tipos de datos simples. Este capítulo
-introducira estructuras de datos básicas. Al final de el, sabrás lo suficiente
+introducirá estructuras de datos básicas. Al final de él, sabrás lo suficiente
 como para comenzar a escribir programas útiles.
 
-El capítulo trabajara a través de un ejemplo de programación más o menos
+El capítulo trabajará a través de un ejemplo de programación más o menos
 realista, presentando nuevos conceptos según se apliquen al problema en
 cuestión. El código de ejemplo a menudo se basara en funciones y vinculaciones
 que fueron introducidas anteriormente en el texto.
@@ -48,7 +48,7 @@ if}}
 {{index "weresquirrel example", lycanthropy}}
 
 De vez en cuando, generalmente entre las ocho y las diez de la noche,
-((Jacques)) se encuentra a si mismo
+((Jacques)) se encuentra a sí mismo
 transformándose en un pequeño roedor peludo con una cola espesa.
 
 Por un lado, Jacques está muy contento de no tener la licantropía clásica.
@@ -63,7 +63,7 @@ pone algunas nueces en el piso para mantenerse ocupado.
 Eso se ocupa de los problemas del gato y el árbol. Pero Jacques preferiría
 deshacerse de su condición por completo. Las ocurrencias irregulares de la
 transformación lo hacen sospechar que estas podrían ser provocadas por
-algo en especifico. Por un tiempo, creyó que solo sucedia en los días
+algo en específico. Por un tiempo, creyó que solo sucedía en los días
 en los que el había estado cerca de árboles de roble. Pero evitar los robles
 no detuvo el problema.
 
@@ -244,12 +244,12 @@ console.log(secuencia);
 
 El método `push` agrega valores al final de un array, y el
 el método `pop` hace lo contrario, eliminando el último valor en el array
-y retornandolo.
+y retornándolo.
 
 Estos nombres algo tontos son los términos tradicionales para las operaciones en
 una _((pila))_. Una pila, en programación, es una ((estructura de datos)) que
 te permite agregar valores a ella y volverlos a sacar en el
-orden opuesto, de modo que lo que se agregó de último se elimine primero.
+orden opuesto, de modo que lo último que se agregó se elimine primero.
 Estas son comunes en la programación—es posible que recuerdes la ((pila))
 de llamadas en [el capítulo anterior](funciones#pila), que es una
 instancia de la misma idea.
@@ -313,7 +313,7 @@ Leer una propiedad que no existe te dará el valor `undefined`.
 {{index [property, assignment], mutability, "= operator"}}
 
 Es posible asignarle un valor a una expresión de propiedad con un
-operador `=`. Esto reemplazará el valor de la propiedad si ya tenia uno
+operador `=`. Esto reemplazará el valor de la propiedad si ya tenía uno
 o crea una nueva propiedad en el objeto si no fuera así.
 
 {{index "tentacle (analogy)", [property, "model of"]}}
@@ -378,7 +378,7 @@ console.log(objetoA);
 
 Los arrays son, entonces, solo un tipo de objeto especializado para almacenar
 secuencias de cosas. Si evalúas `typeof []`, este produce
-`"object"`. Podrias imaginarlos como pulpos largos y planos con todos sus
+`"object"`. Podrías imaginarlos como pulpos largos y planos con todos sus
 tentáculos en una fila ordenada, etiquetados con números.
 
 {{index journal, "weresquirrel example"}}
@@ -424,8 +424,8 @@ diferentes momentos.
 
 Cuando tenemos dos números, 120 y 120, podemos considerarlos el mismo número
 precisamente, ya sea que hagan referencia o no a los mismos bits físicos.
-Con los objetos, hay una diferencia entre tener dos referencias a
-el mismo objeto y tener dos objetos diferentes que contengan las mismas
+Con los objetos, hay una diferencia entre tener dos referencias al 
+mismo objeto y tener dos objetos diferentes que contengan las mismas
 propiedades. Considera el siguiente código:
 
 ```
@@ -448,7 +448,7 @@ console.log(objeto3.valor);
 {{index "tentacle (analogy)", [binding, "model of"]}}
 
 Las vinculaciones `objeto1` y `objeto2` agarran el _mismo_ objeto, que es
-la razon por la cual cambiar `objeto1` también cambia el valor de `objeto2`.
+la razón por la cual cambiar `objeto1` también cambia el valor de `objeto2`.
 Se dice que tienen la misma _identidad_. La vinculación `objeto3` apunta a un
 objeto diferente, que inicialmente contiene las mismas propiedades que
 `objeto1` pero vive una vida separada.
@@ -460,14 +460,14 @@ independiente de la forma en la que se comportan sus valores. Aunque los
 valores numéricos no cambian, puedes usar una ((vinculación)) `let` para hacer
 un seguimiento de un número que cambia al cambiar el valor al que apunta la
 vinculación. Del mismo modo, aunque una vinculación `const` a un objeto no
-pueda ser cambiada en si misma y continuará apuntando al mismo objeto,
+pueda ser cambiada en sí misma y continuará apuntando al mismo objeto,
 los _contenidos_ de ese objeto pueden cambiar.
 
 ```{test: no}
 const puntuacion = {visitantes: 0, locales: 0};
-// Esto esta bien
+// Esto está bien
 puntuacion.visitantes = 1;
-// Esto no esta permitido
+// Esto no está permitido
 puntuacion = {visitantes: 1, locales: 1};
 ```
 
@@ -475,7 +475,7 @@ puntuacion = {visitantes: 1, locales: 1};
 
 Cuando comparas objetos con el operador `==` en JavaScript, este los compara
 por identidad: producirá `true` solo si ambos objetos son precisamente
-el mismo valor. Comparar diferentes objetos retornara `false`, incluso
+el mismo valor. Comparar diferentes objetos retornará `false`, incluso
 si tienen propiedades idénticas. No hay una operación de comparación "profunda"
 incorporada en JavaScript, que compare objetos por contenidos,
 pero es posible que la escribas tu mismo (que es uno de los
@@ -485,7 +485,7 @@ pero es posible que la escribas tu mismo (que es uno de los
 
 {{index "weresquirrel example", lycanthropy, "addEntry function"}}
 
-Asi que Jacques inicia su intérprete de JavaScript y establece el
+Así que Jacques inicia su intérprete de JavaScript y establece el
 entorno que necesita para mantener su ((diario)).
 
 ```{includeCode: true}
@@ -508,11 +508,6 @@ Entonces, todas las noches a las diez—o algunas veces a la mañana siguiente,
 después de bajar del estante superior de su biblioteca—Jacques registra el
 día.
 
-
-So then, every evening at ten—or sometimes the next morning, after
-climbing down from the top shelf of his bookcase—Jacques records the
-day.
-
 ```
 añadirEntrada(["trabajo", "toque un arbol", "pizza", "sali a correr",
           "television"], false);
@@ -536,7 +531,7 @@ generalmente se expresa como un valor que
 varia de -1 a 1. Una correlación de cero significa que las variables no estan
 relacionadas. Una correlación de uno indica que las dos están perfectamente
 relacionadas—si conoces una, también conoces la otra. Uno negativo también
-significa que las variables están perfectamente relacionadas pero que son
+significa que las variables están perfectamente relacionadas, pero que son
 opuestas—cuando una es verdadera, la otra es falsa.
 
 {{index "phi coefficient"}}
@@ -580,14 +575,14 @@ if}}
 if}}
 
 (Si en este momento estas bajando el libro para enfocarte en un terrible
-flashback a la clase de matemática de 10° grado—espera!
+flashback a la clase de matemática de 10° grado—¡espera!
 No tengo la intención de torturarte con infinitas páginas de notación
 críptica—solo esta fórmula para ahora. E incluso con esta,
 todo lo que haremos es convertirla en JavaScript.)
 
 La notación [_n_~01~]{if html}[[$n_{01}$]{latex}]{if tex} indica
 el número de mediciones donde la primera variable (ardilla) es
-falso (0) y la segunda variable (pizza) es verdadera (1). En la tabla
+falsa (0) y la segunda variable (pizza) es verdadera (1). En la tabla
 de pizza, [_n_~01~]{if html}[[$n_{01}$]{latex}]{if tex} es 9.
 
 El valor [_n_~1•~]{if html}[[$n_{1\bullet}$]{latex}]{if tex} se refiere
@@ -698,7 +693,7 @@ en la tabla.
 
 Ahora tenemos las herramientas que necesitamos para calcular las
 ((correlaciónes)) individuales. El único paso que queda es encontrar una
-correlación para cada tipo de evento que se escribio en el diario
+correlación para cada tipo de evento que se escribió en el diario
 y ver si algo se destaca.
 
 {{id for_of_loop}}
@@ -716,9 +711,9 @@ for (let i = 0; i < DIARIO.length; i++) {
 }
 ```
 
-Este tipo de ciclo es común en JavaScript clasico—ir a traves de los arrays
+Este tipo de ciclo es común en JavaScript clásico—ir a través de los arrays
 un elemento a la vez es algo que surge mucho, y para hacer eso
-correrias un contador sobre la longitud del array y elegirías cada
+correrías un contador sobre la longitud del array y elegirías cada
 elemento en turnos.
 
 Hay una forma más simple de escribir tales ciclos en JavaScript moderno.
@@ -804,7 +799,7 @@ for (let evento of eventosDiario(DIARIO)) {
 // → nueces:                  0.5902679812
 ```
 
-A-ha! Hay dos factores con una ((correlación)) que es claramente más fuerte
+¡Aja! Hay dos factores con una ((correlación)) que es claramente más fuerte
 que las otras. Comer ((nueces)) tiene un fuerte efecto positivo en
 la posibilidad de convertirse en una ardilla, mientras que cepillarse
 los dientes tiene un significativo efecto negativo.
@@ -834,7 +829,7 @@ no vuelven.
 Durante algunos años, las cosas van bien para Jacques. Pero en algún momento él
 pierde su trabajo. Porque vive en un país desagradable donde no tener trabajo
 significa que no tiene servicios médicos, se ve obligado a trabajar con
-a ((circo)) donde actua como _El Increible Hombre-Ardilla_,
+un ((circo)) donde actua como _El Increible Hombre-Ardilla_,
 llenando su boca con mantequilla de maní antes de cada presentación.
 
 Un día, harto de esta existencia lamentable, Jacques no puede cambiar
@@ -851,7 +846,7 @@ arrays útiles generalmente.
 
 {{index "push method", "pop method", "shift method", "unshift method"}}
 
-Vimos `push` y `pop`, que agregan y removen elementos en el
+Vimos `push` y `pop`, que agregan y remueven elementos en el
 final de un array, [anteriormente](datos#array_methods) en este
 capítulo. Los métodos correspondientes para agregar y remover cosas en
 el comienzo de un array se llaman `unshift` y `shift`.
@@ -874,7 +869,7 @@ function recordarUrgentemente(tarea) {
 Ese programa administra una cola de tareas. Agregas tareas al final de la
 cola al llamar `recordar("verduras")`, y cuando estés listo para hacer
 algo, llamas a `obtenerTarea()` para obtener (y eliminar) el elemento frontal
-de la cola. La función `recordarUrgentemente` también agrega una tarea pero
+de la cola. La función `recordarUrgentemente` también agrega una tarea, pero
 la agrega al frente en lugar de a la parte posterior de la cola.
 
 {{index [array, searching], "indexOf method", "lastIndexOf method"}}
@@ -884,7 +879,7 @@ Para buscar un valor específico, los arrays proporcionan un método `indexOf`
 Este busca a través del array desde el principio hasta el final y retorna el
 índice en el que se encontró el valor solicitado—o -1 si este no fue encontrado.
 Para buscar desde el final en lugar del inicio, hay un método similar
-llamado `lastIndexOf` ("ultimo indice de").
+llamado `lastIndexOf` ("último índice de").
 
 ```
 console.log([1, 2, 3, 2, 1].indexOf(2));
@@ -917,12 +912,12 @@ para copiar todo el array.
 
 {{index concatenation, "concat method"}}
 
-El método `concat` ("concatenar") se puede usar para unir arrays y asi crear un
+El método `concat` ("concatenar") se puede usar para unir arrays y así crear un
 nuevo array, similar a lo que hace el operador `+` para los strings.
 
 El siguiente ejemplo muestra tanto `concat` como `slice` en acción. Toma un
 array y un índice, y retorna un nuevo array que es una copia del
-array original pero eliminando al elemento en el índice dado:
+array original, pero eliminando al elemento en el índice dado:
 
 ```
 function remover(array, indice) {
@@ -934,7 +929,7 @@ console.log(remover(["a", "b", "c", "d", "e"], 2));
 ```
 
 Si a `concat` le pasas un argumento que no es un array, ese valor
-sera agregado al nuevo array como si este fuera un array de un solo elemento.
+será agregado al nuevo array como si este fuera un array de un solo elemento.
 
 ## Strings y sus propiedades
 
@@ -958,7 +953,7 @@ tales valores son inmutables y no pueden ser cambiados.
 {{index [string, methods], "slice method", "indexOf method", [string, searching]}}
 
 Pero estos tipos tienen propiedades integradas. Cada valor de string tiene un
-numero de metodos. Algunos muy útiles son `slice` e `indexOf`,
+número de métodos. Algunos muy útiles son `slice` e `indexOf`,
 que se parecen a los métodos de array de los mismos nombres.
 
 ```
@@ -1048,8 +1043,8 @@ son dados.
 
 {{indexsee "period character", "max example", spread}}
 
-Para escribir tal función, pones tres puntos antes del ultimo ((parámetro))
-de la función, asi:
+Para escribir tal función, pones tres puntos antes del último ((parámetro))
+de la función, así:
 
 ```
 function maximo(...numeros) {
@@ -1090,9 +1085,6 @@ La notación de corchetes para crear arrays permite al operador de tres-puntos
 extender otro array en el nuevo array:
 
 
-Square bracket array notation similarly allows the triple-dot operator
-to spread another array into the new array:
-
 ```
 let palabras = ["nunca", "entenderas"];
 console.log(["tu", ...palabras, "completamente"]);
@@ -1130,7 +1122,7 @@ Objeto `Math`, no tenemos que preocuparnos por sobrescribirla.
 
 Muchos lenguajes te detendrán, o al menos te advertirán, cuando estes por
 definir una vinculación con un nombre que ya este tomado. JavaScript hace
-esto para vinculaciones que hayas declarado con `let` o` const`
+esto para vinculaciones que hayas declarado con `let` o `const`
 pero-perversamente-no para vinculaciones estándar, ni para
 vinculaciones declaradas con `var` o `function`.
 
@@ -1176,7 +1168,7 @@ console.log(Math.random());
 {{index "pseudorandom number", "random number"}}
 
 Aunque las computadoras son máquinas deterministas—siempre reaccionan de la
-misma manera manera dada la misma entrada—es posible hacer que
+misma manera dada la misma entrada—es posible hacer que
 produzcan números que parecen aleatorios. Para hacer eso, la máquina mantiene
 algun valor escondido, y cada vez que le pidas un nuevo número aleatorio,
 realiza calculos complicados en este valor oculto para crear un nuevo valor.
@@ -1203,9 +1195,9 @@ expresión producirá, con la misma probabilidad, cualquier número desde 0 hast
 {{index "Math.ceil function", "Math.round function", "Math.abs function", "absolute value"}}
 
 También están las funciones `Math.ceil` (que redondea hacia arriba hasta llegar
-al número entero mas cercano), `Math.round` (al número entero más cercano), y
+al número entero más cercano), `Math.round` (al número entero más cercano), y
 `Math.abs`, que toma el valor absoluto de un número, lo que significa que
-niega los valores negativos pero deja los positivos tal y como estan.
+niega los valores negativos, pero deja los positivos tal y como están.
 
 ## Desestructurar
 
@@ -1243,7 +1235,7 @@ function phi([n00, n01, n10, n11]) {
 
 Esto también funciona para ((vinculaciones)) creadas con `let`, `var`, o
 `const`. Si sabes que el valor que estas vinculando es un array, puedes
-usar ((corchetes)) para "mirar dentro" del valor, y asi vincular sus
+usar ((corchetes)) para "mirar dentro" del valor, y así vincular sus
 contenidos.
 
 {{index object, "curly braces"}}
@@ -1269,7 +1261,7 @@ de esos valores.
 Ya que las propiedades solo agarran su valor, en lugar de contenerlo,
 los objetos y arrays se almacenan en la ((memoria)) de la computadora como
 secuencias de bits que contienen las _((dirección))es_—el lugar en la memoria—de
-sus contenidos. Asi que un array con otro array dentro de el consiste
+sus contenidos. Así que un array con otro array dentro de él consiste
 en (al menos) una región de memoria para el array interno, y otra para
 el array externo, que contiene (entre otras cosas) un número binario que
 representa la posición del array interno.
@@ -1300,7 +1292,7 @@ rodeados por comillas dobles, y solo se permiten expresiones de datos
 simples—sin llamadas a función, vinculaciones o cualquier otra cosa que
 involucre computaciones reales. Los comentarios no están permitidos en JSON.
 
-Una entrada de diario podria verse así cuando se representa como datos JSON:
+Una entrada de diario podría verse así cuando se representa como datos JSON:
 
 ```{lang: "application/json"}
 {
@@ -1341,7 +1333,7 @@ generalmente contienen cantidades variables de valores conceptualmente
 idénticos y usa números (comenzando desde 0) como los nombres de sus propiedades.
 
 Hay _algunas_ propiedades con nombre en los arrays, como `length` y un
-numero de metodos. Los métodos son funciones que viven en propiedades y
+número de métodos. Los métodos son funciones que viven en propiedades y
 (por lo general) actuan sobre el valor del que son una propiedad.
 
 Puedes iterar sobre los arrays utilizando un tipo especial de ciclo `for`—`for
@@ -1417,14 +1409,14 @@ el operador `=`) tenga el valor 1.
 {{index "range function", "for loop"}}
 
 Hacer que `rango` entienda valores de paso negativos es probablemente
-mas facil de realizar al escribir dos ciclos por separado—uno para contar
+más fácil de realizar al escribir dos ciclos por separado—uno para contar
 hacia arriba y otro para contar hacia abajo—ya que la comparación que verifica
 si el ciclo está terminado necesita ser `>=` en lugar de `<=` cuando se cuenta
 hacia abajo.
 
 También puede que valga la pena utilizar un paso predeterminado
 diferente, es decir -1, cuando el final del rango sea menor que el inicio.
-De esa manera, `rango(5, 2)` retornaria algo significativo, en lugar de quedarse
+De esa manera, `rango(5, 2)` retornaría algo significativo, en lugar de quedarse
 atascado en un ((ciclo infinito)). Es posible referirse a parámetros anteriores
 en el valor predeterminado de un parámetro.
 
@@ -1446,8 +1438,8 @@ Ninguno de los dos puede usar el método `reverse` estándar.
 {{index efficiency, "pure function", "side effect"}}
 
 Pensando en las notas acerca de los efectos secundarios y las funciones puras en
-el [capítulo anterior](funciones#pura), qué variante esperas que sea
-útil en más situaciones? Cuál corre más rápido?
+el [capítulo anterior](funciones#pura) ¿Qué variante esperas que sea
+útil en más situaciones? ¿Cuál corre más rápido?
 
 {{if interactive
 
@@ -1471,7 +1463,7 @@ if}}
 Hay dos maneras obvias de implementar `revertirArray`. La primera es
 simplemente pasar a traves del array de entrada de adelante hacia atrás y
 usar el metodo `unshift` en el nuevo array para insertar cada elemento en su
-inicio. La segundo es hacer un ciclo sobre el array de entrada de atrás hacia
+inicio. La segunda es hacer un ciclo sobre el array de entrada de atrás hacia
 adelante y usar el método `push`. Iterar sobre un array al revés requiere de
 una especificación (algo incómoda) del ciclo `for`, como
 `(let i = array.length - 1; i >= 0; i--)`.
@@ -1481,11 +1473,11 @@ una especificación (algo incómoda) del ciclo `for`, como
 Revertir al array en su lugar es más difícil. Tienes que tener cuidado de no
 sobrescribir elementos que necesitarás luego. Usar `revertirArray` o
 de lo contrario, copiar toda el array (`array.slice(0)` es una buena forma de
-copiar un array) funciona pero estás haciendo trampa.
+copiar un array) funciona, pero estás haciendo trampa.
 
 El truco consiste en _intercambiar_ el primer y el último elemento,
 luego el segundo y el penúltimo, y así sucesivamente. Puedes hacer esto
-haciendo un ciclo basandote en la mitad de la longitud del array
+haciendo un ciclo basándote en la mitad de la longitud del array
 (use `Math.floor` para redondear—no necesitas tocar el elemento del medio en
 un array con un número impar de elementos) e intercambiar el elemento en
 la posición `i` con el de la posición `array.length - 1 - i`. Puedes usar una
@@ -1583,7 +1575,7 @@ una especificación del ciclo `for` como esta se puede utilizar:
 for (let nodo = lista; nodo; nodo = nodo.resto) {}
 ```
 
-Puedes ver cómo eso funciona? En cada iteración del ciclo, `nodo` apunta
+¿Puedes ver cómo eso funciona? En cada iteración del ciclo, `nodo` apunta
 a la sublista actual, y el cuerpo puede leer su propiedad `valor` para
 obtener el elemento actual. Al final de una iteración, `nodo` se mueve a
 la siguiente sublista. Cuando eso es nulo, hemos llegado al final de la
@@ -1608,7 +1600,7 @@ hint}}
 {{index "deep comparison (exercise)", comparison, "deep comparison", "== operator"}}
 
 El operador `==` compara objetos por identidad. Pero a veces
-preferirias comparar los valores de sus propiedades reales.
+preferirías comparar los valores de sus propiedades reales.
 
 Escribe una función `igualdadProfunda` que toma dos valores y retorne `true`
 solo si tienen el mismo valor o son objetos con las mismas
@@ -1657,7 +1649,7 @@ otros casos, puede retornar inmediatamente el resultado de aplicar `===`.
 {{index "Object.keys function"}}
 
 Usa `Object.keys` para revisar las propiedades. Necesitas probar si
-ambos objetos tienen el mismo conjunto de nombres de propiedad y si esos
+ambos objetos tienen el mismo conjunto de nombres de propiedad y si esas
 propiedades tienen valores idénticos. Una forma de hacerlo es garantizar que
 ambos objetos tengan el mismo número de propiedades (las longitudes de
 las listas de propiedades son las mismas). Y luego, al hacer un ciclo sobre