Jul 15, 2020 · Jul 15, 2020 · Jul 15, 2020 · Jul 15, 2020 · Jul 15, 2020 · Jul 15, 2020
diff --git a/1-js/99-js-misc/02-eval/1-eval-calculator/solution.md b/1-js/99-js-misc/02-eval/1-eval-calculator/solution.md
 Let's use`eval`to calculate the maths expression:
 Usemos`eval`para calcular la expresión matemática:

 ```js demo run
 let expr = prompt("Type an arithmetic expression?", '2*3+2');
 let expr = prompt("Escribe una expresión matemática:", '2*3+2');

 alert( eval(expr) );
 ```

 The user can input any text or code though.
 Aunque el usuario puede ingresar cualquier texto o código.

 To make things safe, and limit it to arithmetics only, we can check the`expr`using a [regular expression](info:regular-expressions), so that it only may contain digits and operators.
 Para hacer las cosas seguras, y limitarlo a aritmética solamente, podemos verificar`expr`usando una [expresión regular](info:regular-expressions) que solo pueda contener dígitos y operadores.
diff --git a/1-js/99-js-misc/02-eval/1-eval-calculator/task.md b/1-js/99-js-misc/02-eval/1-eval-calculator/task.md

 ---

 #Eval-calculator
 #Calculadora-eval

 Create a calculator that prompts for an arithmetic expression and returns its result.
 Crea una calculadora que pida una expresión aritmética y devuelva su resultado.

 There's no need to check the expression for correctness in this task. Just evaluate and return the result.
 No es necesario verificar que la expresión sea correcta en esta tarea. Simplemente que evalue y devuelva el resultado.

 [demo]
diff --git a/1-js/99-js-misc/02-eval/article.md b/1-js/99-js-misc/02-eval/article.md
 # Eval:run a code string
 # Eval:ejecutando una cadena de código

 The built-in`eval`function allows to execute a string of code.
 La función incorporada`eval`permite ejecutar una cadena de código.

 The syntax is:
 La sintaxis es:

 ```js
 let result = eval(code);
 ```

 For example:
 Por ejemplo:

 ```js run
 let code = 'alert("Hello")';
 eval(code); // Hello
 ```

 A string of code may be long, contain line breaks, function declarations, variablesand so on.
 Una cadena de código puede ser larga, contener cortes de línea, declaración de funciones, variablesy así.

 The result of `eval`is the result of the last statement.
 El resultado de `eval`es el resultado de la última sentencia.

 For example:
 Por ejemplo:
 ```js run
 let value = eval('1+1');
 alert(value); // 2
 alert(value); // 1
 ```

 The eval'ed code is executed in the current lexical environment, so it can see outervariables:
 El código evaluado es ejecutado en el entorno léxico presente, entonces podemos ver susvariables externas:

 ```js run no-beautify
 let a = 1;
 f();
 ```

 It can change outervariablesas well:
 También puede modificarvariablesexternas:

 ```js untrusted refresh run
 let x = 5;
 eval("x = 10");
 alert(x); // 10,value modified
 alert(x); // 10,valor modificado
 ```

 In strict mode, `eval`has its own lexical environment. So functions and variables, declared insideeval, are not visible outside:
 En modo estricto, `eval`tiene su propio entorno léxico. Entonces funciones y variables declaradas dentro deeval no son visibles fuera:

 ```js untrusted refresh run
 //reminder: 'use strict'is enabled in runnable examples by default
 //recordatorio: 'use strict'está habilitado en los ejemplos ejecutables por defecto

 eval("let x = 5; function f() {}");

 alert(typeof x); // undefined (nosuch variable)
 //function f is also not visible
 alert(typeof x); // undefined (noexiste tal variable)
 //la función f tampoco es visible
 ```

 Without `use strict`, `eval`doesn't have its own lexical environment, so we would see`x`and `f`outside.
 Sin `use strict`, `eval`no tiene su propio entorno léxico, entonces podemos ver`x`y `f`afuera.

 ##Using "eval"
 ##Usando "eval"

 In modern programming `eval`is used very sparingly. It's often said that "eval is evil".
 En programación moderna `eval`es usado muy ocasionalmente. Se suele decir que "eval is evil" - juego de palabras en inglés que significa en español: "eval es malvado".

 The reason is simple:long, long time ago JavaScriptwas a much weaker language, many things could only be done with `eval`.But that time passed a decade ago.
 La razón es simple:largo, largo tiempo atrás JavaScriptera un lenguaje mucho más débil, muchas cosas podían ser concretadas solamente con `eval`.Pero aquel tiempo pasó hace una década.

 Right now, there's almostnoreason to use`eval`.If someone is using it, there's a goodchancethey can replace it with a modern language construct or a [JavaScript Module](info:modules).
 Ahora casinohay razones para usar`eval`.Si alguien lo está usando, hay buenachancede que pueda ser reemplazado con una construcción moderna del lenguaje o un [Módulo JavaScript](info:modules).

 Please note that its ability to access outervariableshas side-effects.
 Por favor ten en cuenta que su habilidad para acceder avariablesexternas tiene efectos colaterales.

 Code minifiers (tools used before JS gets to production, to compress it) rename local variablesinto shorter ones (like `a`, `b` etc)to make the code smaller. That's usually safe, but not if `eval`is used, as local variablesmay be accessed from eval'ed code string. So minifiers don't do that renaming for allvariablespotentially visible from `eval`.That negatively affects code compression ratio.
 LosCode minifiers (minimizadores de código, herramientas usadas antes de poner JS en producción para comprimirlo) renombran las variableslocales acortándolas (como `a`, `b` etc)para achicar el código. Usualmente esto es seguro, pero no si `eval`es usado porque las variableslocales puden ser accedidas desde la cadena de código evaluada. Por ello los minimizadores no hacen tal renombado en todas lasvariablespotencialmente visibles por `eval`.Esto afecta negativamente en el índice de compresión.

 Using outer local variablesinside`eval`is also considered a bad programming practice, as it makes maintaining the code more difficult.
 El uso de variableslocales dentro de`eval`es también considerado una mala práctica de programación, porque hace el mantenimiento de código más difícil.

 There are two ways how to be totally safe from such problems.
 Hay dos maneras de estar asegurado frente a tales problemas.

 **If eval'ed code doesn't use outer variables, please call`eval`as `window.eval(...)`:**
 **Si el código evaluado no usa variables externas, por favor llama`eval`como `window.eval(...)`:**

 This way the code is executed in the global scope:
 De esta manera el código es ejecutado en el entorno global:

 ```js untrusted refresh run
 let x = 1;
 {
  let x = 5;
  window.eval('alert(x)'); // 1 (globalvariable)
  window.eval('alert(x)'); // 1 (variable global)
 }
 ```

 **If eval'ed code needs local variables, change `eval`to `new Function`and pass them as arguments:**
 **Si el código evaluado necesita variables locales, cambia `eval`por `new Function`y pásalas como argumentos:**

 ```js run
 let f = new Function('a', 'alert(a)');

 f(5); // 5
 ```

 The`new Function`construct is explained in the chapter<info:new-function>.It creates a function from a string, also in theglobal scope. So it can't see local variables. But it's so much clearer to pass them explicitly as arguments, like in the example above.
 La contrucción`new Function`es explicada en el capítulo<info:new-function>.Esta crea una función desde una cadena, también en el entornoglobal, y así no puede ver las variables locales. Pero es mucho más claro pasarlas explícitamente como argumentos como en el ejemplo de arriba.

 ##Summary
 ##Resumen

 A call to `eval(code)`runs the string of code and returns the result of the last statement.
 -Rarely used in modern JavaScript, as there's usuallynoneed.
 -Can access outer localvariables. That's considered bad practice.
 -Instead, to `eval` the code in the global scope, use `window.eval(code)`.
 -Or, if your code needs some data from the outer scope, use `new Function`and pass it as arguments.
 Un llamado a `eval(code)`ejecuta la cadena de código y devuelve el resultado de la última sentencia.
 -Es raramente usado en JavaScript moderno, y usualmentenoes necesario.
 -Puede acceder avariables locales externas. Esto es considerado una mala práctica.
 -En su lugar, para evaluar el código en el entorno global, usa `window.eval(code)`.
 -O, si tu código necesita algunos datos de el entorno externo, usa `new Function`y pásalos como argumentos.
Original file line number	Diff line number	Diff line change
		@@ -1,11 +1,11 @@
		Let's use`eval`to calculate the maths expression:
		Usemos`eval`para calcular la expresión matemática:

		```js demo run
		let expr = prompt("Type an arithmetic expression?", '2*3+2');
		let expr = prompt("Escribe una expresión matemática:", '2*3+2');

		alert( eval(expr) );
		```

		The user can input any text or code though.
		Aunque el usuario puede ingresar cualquier texto o código.

		To make things safe, and limit it to arithmetics only, we can check the`expr`using a [regular expression](info:regular-expressions), so that it only may contain digits and operators.
		Para hacer las cosas seguras, y limitarlo a aritmética solamente, podemos verificar`expr`usando una [expresión regular](info:regular-expressions) que solo pueda contener dígitos y operadores.
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,10 +2,10 @@ importance: 4

		---

		#Eval-calculator
		#Calculadora-eval

		Create a calculator that prompts for an arithmetic expression and returns its result.
		Crea una calculadora que pida una expresión aritmética y devuelva su resultado.

		There's no need to check the expression for correctness in this task. Just evaluate and return the result.
		No es necesario verificar que la expresión sea correcta en esta tarea. Simplemente que evalue y devuelva el resultado.

		[demo]
Original file line number	Diff line number	Diff line change
		@@ -1,25 +1,25 @@
		# Eval:run a code string
		# Eval:ejecutando una cadena de código

		The built-in`eval`function allows to execute a string of code.
		La función incorporada`eval`permite ejecutar una cadena de código.

		The syntax is:
		La sintaxis es:

		```js
		let result = eval(code);
		```

		For example:
		Por ejemplo:

		```js run
		let code = 'alert("Hello")';
		eval(code); // Hello
		```

		A string of code may be long, contain line breaks, function declarations, variablesand so on.
		Una cadena de código puede ser larga, contener cortes de línea, declaración de funciones, variablesy así.

		The result of `eval`is the result of the last statement.
		El resultado de `eval`es el resultado de la última sentencia.

		For example:
		Por ejemplo:
		```js run
		let value = eval('1+1');
		alert(value); // 2
Expand All		@@ -30,7 +30,7 @@ let value = eval('let i = 0; ++i');
		alert(value); // 1
		```

		The eval'ed code is executed in the current lexical environment, so it can see outervariables:
		El código evaluado es ejecutado en el entorno léxico presente, entonces podemos ver susvariables externas:

		```js run no-beautify
		let a = 1;
Expand All		@@ -46,69 +46,69 @@ function f() {
		f();
		```

		It can change outervariablesas well:
		También puede modificarvariablesexternas:

		```js untrusted refresh run
		let x = 5;
		eval("x = 10");
		alert(x); // 10,value modified
		alert(x); // 10,valor modificado
		```

		In strict mode, `eval`has its own lexical environment. So functions and variables, declared insideeval, are not visible outside:
		En modo estricto, `eval`tiene su propio entorno léxico. Entonces funciones y variables declaradas dentro deeval no son visibles fuera:

		```js untrusted refresh run
		//reminder: 'use strict'is enabled in runnable examples by default
		//recordatorio: 'use strict'está habilitado en los ejemplos ejecutables por defecto

		eval("let x = 5; function f() {}");

		alert(typeof x); // undefined (nosuch variable)
		//function f is also not visible
		alert(typeof x); // undefined (noexiste tal variable)
		//la función f tampoco es visible
		```

		Without `use strict`, `eval`doesn't have its own lexical environment, so we would see`x`and `f`outside.
		Sin `use strict`, `eval`no tiene su propio entorno léxico, entonces podemos ver`x`y `f`afuera.

		##Using "eval"
		##Usando "eval"

		In modern programming `eval`is used very sparingly. It's often said that "eval is evil".
		En programación moderna `eval`es usado muy ocasionalmente. Se suele decir que "eval is evil" - juego de palabras en inglés que significa en español: "eval es malvado".

		The reason is simple:long, long time ago JavaScriptwas a much weaker language, many things could only be done with `eval`.But that time passed a decade ago.
		La razón es simple:largo, largo tiempo atrás JavaScriptera un lenguaje mucho más débil, muchas cosas podían ser concretadas solamente con `eval`.Pero aquel tiempo pasó hace una década.

		Right now, there's almostnoreason to use`eval`.If someone is using it, there's a goodchancethey can replace it with a modern language construct or a [JavaScript Module](info:modules).
		Ahora casinohay razones para usar`eval`.Si alguien lo está usando, hay buenachancede que pueda ser reemplazado con una construcción moderna del lenguaje o un [Módulo JavaScript](info:modules).

		Please note that its ability to access outervariableshas side-effects.
		Por favor ten en cuenta que su habilidad para acceder avariablesexternas tiene efectos colaterales.

		Code minifiers (tools used before JS gets to production, to compress it) rename local variablesinto shorter ones (like `a`, `b` etc)to make the code smaller. That's usually safe, but not if `eval`is used, as local variablesmay be accessed from eval'ed code string. So minifiers don't do that renaming for allvariablespotentially visible from `eval`.That negatively affects code compression ratio.
		LosCode minifiers (minimizadores de código, herramientas usadas antes de poner JS en producción para comprimirlo) renombran las variableslocales acortándolas (como `a`, `b` etc)para achicar el código. Usualmente esto es seguro, pero no si `eval`es usado porque las variableslocales puden ser accedidas desde la cadena de código evaluada. Por ello los minimizadores no hacen tal renombado en todas lasvariablespotencialmente visibles por `eval`.Esto afecta negativamente en el índice de compresión.

		Using outer local variablesinside`eval`is also considered a bad programming practice, as it makes maintaining the code more difficult.
		El uso de variableslocales dentro de`eval`es también considerado una mala práctica de programación, porque hace el mantenimiento de código más difícil.

		There are two ways how to be totally safe from such problems.
		Hay dos maneras de estar asegurado frente a tales problemas.

		If eval'ed code doesn't use outer variables, please call`eval`as `window.eval(...)`:
		Si el código evaluado no usa variables externas, por favor llama`eval`como `window.eval(...)`:

		This way the code is executed in the global scope:
		De esta manera el código es ejecutado en el entorno global:

		```js untrusted refresh run
		let x = 1;
		{
		let x = 5;
		window.eval('alert(x)'); // 1 (globalvariable)
		window.eval('alert(x)'); // 1 (variable global)
		}
		```

		If eval'ed code needs local variables, change `eval`to `new Function`and pass them as arguments:
		Si el código evaluado necesita variables locales, cambia `eval`por `new Function`y pásalas como argumentos:

		```js run
		let f = new Function('a', 'alert(a)');

		f(5); // 5
		```

		The`new Function`construct is explained in the chapter<info:new-function>.It creates a function from a string, also in theglobal scope. So it can't see local variables. But it's so much clearer to pass them explicitly as arguments, like in the example above.
		La contrucción`new Function`es explicada en el capítulo<info:new-function>.Esta crea una función desde una cadena, también en el entornoglobal, y así no puede ver las variables locales. Pero es mucho más claro pasarlas explícitamente como argumentos como en el ejemplo de arriba.

		##Summary
		##Resumen

		A call to `eval(code)`runs the string of code and returns the result of the last statement.
		-Rarely used in modern JavaScript, as there's usuallynoneed.
		-Can access outer localvariables. That's considered bad practice.
		-Instead, to `eval` the code in the global scope, use `window.eval(code)`.
		-Or, if your code needs some data from the outer scope, use `new Function`and pass it as arguments.
		Un llamado a `eval(code)`ejecuta la cadena de código y devuelve el resultado de la última sentencia.
		-Es raramente usado en JavaScript moderno, y usualmentenoes necesario.
		-Puede acceder avariables locales externas. Esto es considerado una mala práctica.
		-En su lugar, para evaluar el código en el entorno global, usa `window.eval(code)`.
		-O, si tu código necesita algunos datos de el entorno externo, usa `new Function`y pásalos como argumentos.