Una sentencia block se utiliza para agrupar cero o más sentencias. Este grupo block se delimita por un par de llaves.
-
-Esta sentencia se utiliza comúnmente para controlar sentencias de flujo (es decir if, for, while). Por ejemplo:
-
-Termina el bucle actual, sentecia switch o label y transfiere el control del programa a la siguiente sentencia a la sentecia de terminación de éstos elementos.
-La siguiente función tiene una sentencia que termina el bucle {{jsxref("Sentencias/while", "while")}} cuando i es 3, y entonces devuelve el valor 3 * x.
-De la misma manera que con las expresiones de clase, el contenido de una clase se ejecuta en modo estricto.
-
-Las declaraciones de clases no están {{Glossary("Hoisting", "izadas")}} (al contrario que las declaraciones de funciones).
-
-La declaración de una constante crea una referencia de sólo lectura. No significa que el valor que tiene sea inmutable, sino que el identificador de variable no puede ser reasignado, por lo tanto, en el caso de que la asignación a la constante sea un objeto, el objeto sí que puede ser alterado.
-
-Termina la ejecución de las sentencias de la iteración actual del bucle actual o la etiqueta y continua la ejecución del bucle con la próxima iteración.
-El siguiente ejemplo muestra un bucle {{jsxref("Sentencias/while", "while")}} que tiene una sentencia continue que se ejecuta cuando el valor de i es 3. Así, n toma los valores 1, 3, 7 y 12.
-El siguiente ejemplo muestra un bloque de código donde ha sido insertada una sentencia debugger, para invocar el depurador (si existe) cuando la función es ejecutada.
-
-Cuando el depurador es invocado, la ejecución se detiene en la sentencia debugger. Es como un punto de interrupción en el script.
-
-)
+
+## Especificaciones
+
+| Specification | Status | Comment |
+| ------------------------------------------------------------------------------------------------ | ---------------------------- | -------------------------------------- |
+| {{SpecName('ESDraft', '#sec-debugger-statement', 'Debugger statement')}} | {{Spec2('ESDraft')}} | |
+| {{SpecName('ES6', '#sec-debugger-statement', 'Debugger statement')}} | {{Spec2('ES6')}} | |
+| {{SpecName('ES5.1', '#sec-12.15', 'Debugger statement')}} | {{Spec2('ES5.1')}} | Definición inicial |
+| {{SpecName('ES3', '#sec-7.5.3', 'Debugger statement')}} | {{Spec2('ES3')}} | |
+| {{SpecName('ES1', '#sec-7.4.3', 'Debugger statement')}} | {{Spec2('ES1')}} | Solo mencionada como palabra reservada |
+
+## Compatibilidad con navegadores
+
+{{Compat("javascript.statements.debugger")}}
+
+## Vea también
+
+- [Debugging JavaScript](/es/docs/Debugging_JavaScript)
+- [The Debugger in the Firefox Developer Tools](/es/docs/Tools/Debugger)
diff --git a/files/es/web/javascript/reference/statements/do...while/index.html b/files/es/web/javascript/reference/statements/do...while/index.html
deleted file mode 100644
index b1c6ff2ea8c2d8..00000000000000
--- a/files/es/web/javascript/reference/statements/do...while/index.html
+++ /dev/null
@@ -1,50 +0,0 @@
----
-title: do...while
-slug: Web/JavaScript/Reference/Statements/do...while
-tags:
- - JavaScript
- - Statement
-translation_of: Web/JavaScript/Reference/Statements/do...while
-original_slug: Web/JavaScript/Referencia/Sentencias/do...while
----
-{{jsSidebar("Statements")}}
-
-La sentencia (hacer mientras) crea un bucle que ejecuta una sentencia especificada, hasta que la condición de comprobación se evalúa como falsa. La condición se evalúa después de ejecutar la sentencia, dando como resultado que la sentencia especificada se ejecute al menos una vez.
-
-{{EmbedInteractiveExample("pages/js/statement-dowhile.html")}}
-
-Sintaxis
-
-do
- sentencia
-while (condición);
-
-
-
- sentencia- Una sentencia que se ejecuta al menos una vez y es reejecutada cada vez que la condición se evalúa a verdadera. Para ejecutar múltiples sentencias dentro de un bucle, utilice la sentencia {{jsxref("Statements/block", "block")}} (
{ ... }) para agrupar aquellas sentencias.
-
-
-
- condición- Una expresión se evalúa después de cada pase del bucle. Si
condición se evalúa como verdadera, la sentencia se re-ejecuta. Cuando condición se evalúa como falsa, el control pasa a la siguiente sentencia hacer mientras.
-
-
-Ejemplos
-
-Usando hacer mientras
-
-En el siguiente ejemplo, el bucle hacer mientras itera al menos una vez y se reitera hasta que i ya no sea menor que 5.
-
-do {
- i += 1;
- document.write(i);
-} while (i < 5);
-
-
-Vea También
-
-
- - {{jsxref("Sentencias/while", "while")}}
- - {{jsxref("Sentencias/for", "for")}}
-
diff --git a/files/es/web/javascript/reference/statements/do...while/index.md b/files/es/web/javascript/reference/statements/do...while/index.md
new file mode 100644
index 00000000000000..6e5cf07da3785d
--- /dev/null
+++ b/files/es/web/javascript/reference/statements/do...while/index.md
@@ -0,0 +1,44 @@
+---
+title: do...while
+slug: Web/JavaScript/Reference/Statements/do...while
+tags:
+ - JavaScript
+ - Statement
+translation_of: Web/JavaScript/Reference/Statements/do...while
+original_slug: Web/JavaScript/Referencia/Sentencias/do...while
+---
+{{jsSidebar("Statements")}}
+
+La sentencia (hacer mientras) crea un bucle que ejecuta una sentencia especificada, hasta que la condición de comprobación se evalúa como falsa. La condición se evalúa después de ejecutar la sentencia, dando como resultado que la sentencia especificada se ejecute al menos una vez.
+
+{{EmbedInteractiveExample("pages/js/statement-dowhile.html")}}
+
+## Sintaxis
+
+ do
+ sentencia
+ while (condición);
+
+- `sentencia`
+ - : Una sentencia que se ejecuta al menos una vez y es reejecutada cada vez que la condición se evalúa a verdadera. Para ejecutar múltiples sentencias dentro de un bucle, utilice la sentencia {{jsxref("Statements/block", "block")}} (`{ ... }`) para agrupar aquellas sentencias.
+
+- `condición`
+ - : Una expresión se evalúa después de cada pase del bucle. Si `condición` se evalúa como verdadera, la `sentencia` se re-ejecuta. Cuando `condición` se evalúa como falsa, el control pasa a la siguiente sentencia hacer mientras.
+
+## Ejemplos
+
+### Usando `hacer mientras`
+
+En el siguiente ejemplo, el bucle hacer mientras itera al menos una vez y se reitera hasta que `i` ya no sea menor que 5.
+
+```js
+do {
+ i += 1;
+ document.write(i);
+} while (i < 5);
+```
+
+## Vea También
+
+- {{jsxref("Sentencias/while", "while")}}
+- {{jsxref("Sentencias/for", "for")}}
diff --git a/files/es/web/javascript/reference/statements/empty/index.html b/files/es/web/javascript/reference/statements/empty/index.html
deleted file mode 100644
index 64613571ad4431..00000000000000
--- a/files/es/web/javascript/reference/statements/empty/index.html
+++ /dev/null
@@ -1,94 +0,0 @@
----
-title: empty
-slug: Web/JavaScript/Reference/Statements/Empty
-tags:
- - JavaScript
- - Sentencia
- - Vacía
-translation_of: Web/JavaScript/Reference/Statements/Empty
-original_slug: Web/JavaScript/Referencia/Sentencias/Empty
----
-{{jsSidebar("Statements")}}
-
-Un empty statement o sentencia vacía es usada para no proveer una sentencia, incluso si la sintaxis JavaScript esperase una.
-
-Sintaxis
-
-;
-
-
-Descripción
-
-La sentencia vacía es un punto y coma (;) que indica que no se ejecutará ninguna sentencia, incluso si la sintaxis JavaScript requiere una. El comportamiento opuesto, donde se desean ejecutar varias sentencias pero JavaScript solo permite una sola, es posible usando una sentencia de bloque; la cual combina varias declaraciones en una.
-
-Ejemplos
-
-La sentencia vacía es comúnmente usada en bucles. Por ejemplo, un bucle for sin bloque de sentencias:
-
-var arr = [1, 2, 3];
-
-// Asignar el valor 0 a todos los elementos del array
-for (i = 0; i < arr.length; arr[i++] = 0) /* sentencia vacía */ ;
-
-console.log(arr);
-// [0, 0, 0]
-
-
-Nota: Es una buena práctica comentar el uso intencional de la sentencia vacía, ya que no es fácilmente distinguible de un punto y coma normal. Un ejemplo de uso probablemente no intencional:
-
-if (condicion); // Esta condición no ejerce ningún control!
- borrarTodo() // Por lo cual esta sentencia será ejecutada siempre!!!
-
-
-Otro ejemplo de uso:
-
-var a = 1, b = 1;
-if((a == 0) || (b = 0)); // Asigna a 'b' el valor cero si 'a' no es cero.
-console.log(b); // 0
-
-Especificaciones
-
-
-
-
- | Especificación |
- Estado |
- Comentario |
-
-
- | {{SpecName('ESDraft', '#sec-empty-statement', 'Empty statement')}} |
- {{Spec2('ESDraft')}} |
- |
-
-
- | {{SpecName('ES6', '#sec-empty-statement', 'Empty statement')}} |
- {{Spec2('ES6')}} |
- |
-
-
- | {{SpecName('ES5.1', '#sec-12.3', 'Empty statement')}} |
- {{Spec2('ES5.1')}} |
- |
-
-
- | {{SpecName('ES3', '#sec-12.3', 'Empty statement')}} |
- {{Spec2('ES3')}} |
- |
-
-
- | {{SpecName('ES1', '#sec-12.3', 'Empty statement')}} |
- {{Spec2('ES1')}} |
- Definición inicial. |
-
-
-
-
-Compatibilidad en Navegadores
-
-{{Compat("javascript.statements.empty")}}
-
-Vea también
-
-
- - {{jsxref("Sentencias/block", "Sentencia de bloque")}}
-
diff --git a/files/es/web/javascript/reference/statements/empty/index.md b/files/es/web/javascript/reference/statements/empty/index.md
new file mode 100644
index 00000000000000..bb720acb6e586a
--- /dev/null
+++ b/files/es/web/javascript/reference/statements/empty/index.md
@@ -0,0 +1,68 @@
+---
+title: empty
+slug: Web/JavaScript/Reference/Statements/Empty
+tags:
+ - JavaScript
+ - Sentencia
+ - Vacía
+translation_of: Web/JavaScript/Reference/Statements/Empty
+original_slug: Web/JavaScript/Referencia/Sentencias/Empty
+---
+{{jsSidebar("Statements")}}
+
+Un **empty statement** o sentencia vacía es usada para no proveer una sentencia, incluso si la sintaxis JavaScript esperase una.
+
+## Sintaxis
+
+ ;
+
+## Descripción
+
+La sentencia vacía es un punto y coma (;) que indica que no se ejecutará ninguna sentencia, incluso si la sintaxis JavaScript requiere una. El comportamiento opuesto, donde se desean ejecutar varias sentencias pero JavaScript solo permite una sola, es posible usando una [sentencia de bloque](/es/docs/Web/JavaScript/Referencia/Sentencias/block); la cual combina varias declaraciones en una.
+
+## Ejemplos
+
+La sentencia vacía es comúnmente usada en bucles. Por ejemplo, un bucle for sin bloque de sentencias:
+
+```js
+var arr = [1, 2, 3];
+
+// Asignar el valor 0 a todos los elementos del array
+for (i = 0; i < arr.length; arr[i++] = 0) /* sentencia vacía */ ;
+
+console.log(arr);
+// [0, 0, 0]
+```
+
+**Nota:** Es una buena práctica comentar el uso intencional de la sentencia vacía, ya que no es fácilmente distinguible de un punto y coma normal. Un ejemplo de uso probablemente no intencional:
+
+```js
+if (condicion); // Esta condición no ejerce ningún control!
+ borrarTodo() // Por lo cual esta sentencia será ejecutada siempre!!!
+```
+
+Otro ejemplo de uso:
+
+```js
+var a = 1, b = 1;
+if((a == 0) || (b = 0)); // Asigna a 'b' el valor cero si 'a' no es cero.
+console.log(b); // 0
+```
+
+## Especificaciones
+
+| Especificación | Estado | Comentario |
+| ---------------------------------------------------------------------------------------- | ---------------------------- | ------------------- |
+| {{SpecName('ESDraft', '#sec-empty-statement', 'Empty statement')}} | {{Spec2('ESDraft')}} | |
+| {{SpecName('ES6', '#sec-empty-statement', 'Empty statement')}} | {{Spec2('ES6')}} | |
+| {{SpecName('ES5.1', '#sec-12.3', 'Empty statement')}} | {{Spec2('ES5.1')}} | |
+| {{SpecName('ES3', '#sec-12.3', 'Empty statement')}} | {{Spec2('ES3')}} | |
+| {{SpecName('ES1', '#sec-12.3', 'Empty statement')}} | {{Spec2('ES1')}} | Definición inicial. |
+
+## Compatibilidad en Navegadores
+
+{{Compat("javascript.statements.empty")}}
+
+## Vea también
+
+- {{jsxref("Sentencias/block", "Sentencia de bloque")}}
diff --git a/files/es/web/javascript/reference/statements/export/index.html b/files/es/web/javascript/reference/statements/export/index.html
deleted file mode 100644
index 2c700f6f944c29..00000000000000
--- a/files/es/web/javascript/reference/statements/export/index.html
+++ /dev/null
@@ -1,176 +0,0 @@
----
-title: export
-slug: Web/JavaScript/Reference/Statements/export
-tags:
- - ECMAScript 2015
- - JavaScript
- - Módulos
- - Sentencia
- - export
-translation_of: Web/JavaScript/Reference/Statements/export
-original_slug: Web/JavaScript/Referencia/Sentencias/export
----
-{{jsSidebar("Statements")}}
-
-La declaración export se utiliza al crear módulos de JavaScript para exportar funciones, objetos o tipos de dato primitivos del módulo para que puedan ser utilizados por otros programas con la sentencia {{jsxref("Statements/import", "import")}}.
-
-Los módulos exportados están en {{jsxref("Strict_mode","strict mode")}} tanto si se declaran así como si no. La sentencia export no puede ser utilizada en scripts embebidos.
-
-Sintaxis
-
-export { name1, name2, …, nameN };
-export { variable1 as name1, variable2 as name2, …, nameN };
-export let name1, name2, …, nameN; // también var
-export let name1 = …, name2 = …, …, nameN; // también var, const
-export function FunctionName(){...}
-export class ClassName {...}
-
-export default expression;
-export default function (…) { … } // también class, function*
-export default function name1(…) { … } // también class, function*
-export { name1 as default, … };
-
-export * from …;
-export { name1, name2, …, nameN } from …;
-export { import1 as name1, import2 as name2, …, nameN } from …;
-export { default } from …;
-
-
-
- nameN- Identificador a ser exportado (es posible importarlo a través de {{jsxref("Statements/import", "import")}} en otro script).
-
-
-Descripción
-
-Existen dos tipos diferentes de exportación , nombrada y por defecto. Se pueden tener varias exportaciones nombradas por módulo pero sólo una exportación por defecto. Cada tipo corresponde a una de las sintaxis siguientes:
-
-
-
-Los export con nombre son útiles cuando se necesitan exportar múltiples valores. Durante el import, es obligatorio usar el mismo nombre que el correspondiente objeto.
-
-Pero un export por defecto puede ser importado con cualquier nombre, por ejemplo:
-
-export default k = 12; // en el archivo test.js
-
-import m from './test' // notese que tenemos la libertad de usar import m en lugar de import k, porque k era el export por defecto
-
-console.log(m); // escribirá 12
-
-Sólo puede haber un export por defecto.
-
-La siguiente sintaxis no exporta un export por defecto del módulo importado:
-
-export * from …;
-
-Si necesita exportar por defecto, escriba lo siguiente en su lugar:
-
-import mod from 'mod';
-export default mod;
-
-Ejemplos
-
-Usando exports con nombre
-
-En el módulo, podremos usar el siguiente código:
-
-// module "my-module.js"
-function cube(x) {
- return x * x * x;
-}
-const foo = Math.PI + Math.SQRT2;
-var graph = {
- options:{
- color:'white',
- thickness:'2px'
- },
- draw: function(){
- console.log('From graph draw function');
- }
-}
-export { cube, foo, graph };
-
-De esta forma, en otro script, podemos tener:
-
-//You should use this script in html with the type module ,
-//eg ''<script type="module" src="demo.js"></script>",
-//open the page in a httpserver,otherwise there will be a CORS policy error.
-//script demo.js
-
-import { cube, foo, graph } from 'my-module';
-graph.options = {
- color:'blue',
- thickness:'3px'
-};
-graph.draw();
-console.log(cube(3)); // 27
-console.log(foo); // 4.555806215962888
-
-
-Usando el export por defecto
-
-Si queremos exportar un sólo valor o tener uno por defecto para nuestro módulo, podemos usar un export por defecto:
-
-// module "my-module.js"
-export default function cube(x) {
- return x * x * x;
-}
-
-
-De esta forma la importación de un export default será sumamemte sencilla:
-
-import cube from 'my-module';
-console.log(cube(3)); // 27
-
-Tenga en cuenta que no es posible usar var, let o const con export default.
-
-Especificaciones
-
-
-
-
- | Especificación |
- Estado |
- Comentario |
-
-
- | {{SpecName('ES6', '#sec-exports', 'Exports')}} |
- {{Spec2('ES6')}} |
- Definición inicial. |
-
-
- | {{SpecName('ESDraft', '#sec-exports', 'Exports')}} |
- {{Spec2('ESDraft')}} |
- |
-
-
-
-
-Compatiblidad en navegadores
-
-{{Compat("javascript.statements.export")}}
-
-Vea también
-
-
-
-
diff --git a/files/es/web/javascript/reference/statements/export/index.md b/files/es/web/javascript/reference/statements/export/index.md
new file mode 100644
index 00000000000000..4de1384b97edb9
--- /dev/null
+++ b/files/es/web/javascript/reference/statements/export/index.md
@@ -0,0 +1,174 @@
+---
+title: export
+slug: Web/JavaScript/Reference/Statements/export
+tags:
+ - ECMAScript 2015
+ - JavaScript
+ - Módulos
+ - Sentencia
+ - export
+translation_of: Web/JavaScript/Reference/Statements/export
+original_slug: Web/JavaScript/Referencia/Sentencias/export
+---
+{{jsSidebar("Statements")}}
+
+La declaración **`export`** se utiliza al crear módulos de JavaScript para exportar funciones, objetos o tipos de dato primitivos del módulo para que puedan ser utilizados por otros programas con la sentencia {{jsxref("Statements/import", "import")}}.
+
+Los módulos exportados están en {{jsxref("Strict_mode","strict mode")}} tanto si se declaran así como si no. La sentencia export no puede ser utilizada en scripts embebidos.
+
+## Sintaxis
+
+```js
+export { name1, name2, …, nameN };
+export { variable1 as name1, variable2 as name2, …, nameN };
+export let name1, name2, …, nameN; // también var
+export let name1 = …, name2 = …, …, nameN; // también var, const
+export function FunctionName(){...}
+export class ClassName {...}
+
+export default expression;
+export default function (…) { … } // también class, function*
+export default function name1(…) { … } // también class, function*
+export { name1 as default, … };
+
+export * from …;
+export { name1, name2, …, nameN } from …;
+export { import1 as name1, import2 as name2, …, nameN } from …;
+export { default } from …;
+```
+
+- `nameN`
+ - : Identificador a ser exportado (es posible importarlo a través de {{jsxref("Statements/import", "import")}} en otro script).
+
+## Descripción
+
+Existen dos tipos diferentes de exportación , **nombrada** y **por defecto**. Se pueden tener varias exportaciones nombradas por módulo pero sólo una exportación por defecto. Cada tipo corresponde a una de las sintaxis siguientes:
+
+- Exports con nombre:
+
+ ```js
+ // exporta la función previamente declarada
+ export { myFunction };
+
+ // exporta una constante
+ export const foo = Math.sqrt(2);
+ ```
+
+- Exports por defecto (function):
+
+ ```js
+ export default function() {}
+ ```
+
+- Exports por defecto (class):
+
+ ```js
+ export default class {}
+ ```
+
+Los export con nombre son útiles cuando se necesitan exportar múltiples valores. Durante el import, es obligatorio usar el mismo nombre que el correspondiente objeto.
+
+Pero un export por defecto puede ser importado con cualquier nombre, por ejemplo:
+
+```js
+export default k = 12; // en el archivo test.js
+
+import m from './test' // notese que tenemos la libertad de usar import m en lugar de import k, porque k era el export por defecto
+
+console.log(m); // escribirá 12
+```
+
+Sólo puede haber un export por defecto.
+
+La siguiente sintaxis no exporta un export por defecto del módulo importado:
+
+```js
+export * from …;
+```
+
+Si necesita exportar por defecto, escriba lo siguiente en su lugar:
+
+```js
+import mod from 'mod';
+export default mod;
+```
+
+## Ejemplos
+
+### Usando exports con nombre
+
+En el módulo, podremos usar el siguiente código:
+
+```js
+// module "my-module.js"
+function cube(x) {
+ return x * x * x;
+}
+const foo = Math.PI + Math.SQRT2;
+var graph = {
+ options:{
+ color:'white',
+ thickness:'2px'
+ },
+ draw: function(){
+ console.log('From graph draw function');
+ }
+}
+export { cube, foo, graph };
+```
+
+De esta forma, en otro script, podemos tener:
+
+```js
+//You should use this script in html with the type module ,
+//eg ''",
+//open the page in a httpserver,otherwise there will be a CORS policy error.
+//script demo.js
+
+import { cube, foo, graph } from 'my-module';
+graph.options = {
+ color:'blue',
+ thickness:'3px'
+};
+graph.draw();
+console.log(cube(3)); // 27
+console.log(foo); // 4.555806215962888
+```
+
+### Usando el export por defecto
+
+Si queremos exportar un sólo valor o tener uno por defecto para nuestro módulo, podemos usar un export por defecto:
+
+```js
+// module "my-module.js"
+export default function cube(x) {
+ return x * x * x;
+}
+```
+
+De esta forma la importación de un export default será sumamemte sencilla:
+
+```js
+import cube from 'my-module';
+console.log(cube(3)); // 27
+```
+
+Tenga en cuenta que no es posible usar `var`, `let` o `const` con `export default`.
+
+## Especificaciones
+
+| Especificación | Estado | Comentario |
+| -------------------------------------------------------------------- | ---------------------------- | ------------------- |
+| {{SpecName('ES6', '#sec-exports', 'Exports')}} | {{Spec2('ES6')}} | Definición inicial. |
+| {{SpecName('ESDraft', '#sec-exports', 'Exports')}} | {{Spec2('ESDraft')}} | |
+
+## Compatiblidad en navegadores
+
+{{Compat("javascript.statements.export")}}
+
+## Vea también
+
+- {{jsxref("Sentencias/import", "import")}}
+- [ES6 in Depth: Modules](https://hacks.mozilla.org/2015/08/es6-in-depth-modules/), publicación del blog de Hacks por Jason Orendorff
+- [ES modules: A cartoon deep-dive](https://hacks.mozilla.org/2018/03/es-modules-a-cartoon-deep-dive/), publicación del blog de Hacks por Lin Clark
+- [Libro de Axel Rauschmayer: "Exploring JS: Modules"](http://exploringjs.com/es6/ch_modules.html)
diff --git a/files/es/web/javascript/reference/statements/for...of/index.html b/files/es/web/javascript/reference/statements/for...of/index.html
deleted file mode 100644
index 593c48f2cf1024..00000000000000
--- a/files/es/web/javascript/reference/statements/for...of/index.html
+++ /dev/null
@@ -1,263 +0,0 @@
----
-title: for...of
-slug: Web/JavaScript/Reference/Statements/for...of
-tags:
- - ECMAScript6
- - JavaScript
- - Referencia
- - Sentencia
-translation_of: Web/JavaScript/Reference/Statements/for...of
-original_slug: Web/JavaScript/Referencia/Sentencias/for...of
----
-
-
{{jsSidebar("Statements")}}
-
-
La sentencia sentencia for...of ejecuta un bloque de código para cada elemento de un objeto iterable, como lo son: {{jsxref("String")}}, {{jsxref("Array")}}, objetos similares a array (por ejemplo, {{jsxref("Functions/arguments", "arguments")}} or NodeList), {{jsxref("TypedArray")}}, {{jsxref("Map")}}, {{jsxref("Set")}} e iterables definidos por el usuario.
-
Sintaxis
-
-for (variable of iterable) {
- statement
-}
-
-
-
- variable- En cada iteración el elemento (propiedad enumerable) correspondiente es asignado a variable.
- iterable- Objeto cuyas propiedades enumerables son iteradas.
-
-
-Ejemplos
-
-Iterando un {{jsxref("Array")}}
-
-let iterable = [10, 20, 30];
-
-for (let value of iterable) {
- value += 1;
- console.log(value);
-}
-// 11
-// 21
-// 31
-
-
-Es posible usar const en lugar de let si no se va a modificar la variable dentro del bloque.
-
-let iterable = [10, 20, 30];
-
-for (const value of iterable) {
- console.log(value);
-}
-// 10
-// 20
-// 30
-
-Iterando un {{jsxref("String")}}
-
-let iterable = "boo";
-
-for (let value of iterable) {
- console.log(value);
-}
-// "b"
-// "o"
-// "o"
-
-Iterando un {{jsxref("TypedArray")}}
-
-let iterable = new Uint8Array([0x00, 0xff]);
-
-for (let value of iterable) {
- console.log(value);
-}
-// 0
-// 255
-
-Iterando un {{jsxref("Map")}}
-
-let iterable = new Map([["a", 1], ["b", 2], ["c", 3]]);
-
-for (let entry of iterable) {
- console.log(entry);
-}
-// ['a', 1]
-// ['b', 2]
-// ['c', 3]
-
-for (let [key, value] of iterable) {
- console.log(value);
-}
-// 1
-// 2
-// 3
-
-Iterando un {{jsxref("Set")}}
-
-let iterable = new Set([1, 1, 2, 2, 3, 3]);
-
-for (let value of iterable) {
- console.log(value);
-}
-// 1
-// 2
-// 3
-
-Iterando un objeto arguments
-
-(function() {
- for (let argument of arguments) {
- console.log(argument);
- }
-})(1, 2, 3);
-
-// 1
-// 2
-// 3
-
-Iterando una colección del DOM
-
-Iterando colecciones del DOM como un {{domxref("NodeList")}}: el siguiente ejemplo añade la clase "read" a los párrafos (<p>) que son descendientes directos de un (<article>):
-
-// Nota: Esto solo funcionará en plataformas que tengan
-// implementado NodeList.prototype[Symbol.iterator]
-let articleParagraphs = document.querySelectorAll("article > p");
-
-for (let paragraph of articleParagraphs) {
- paragraph.classList.add("read");
-}
-
-Clausurando iteraciones
-
-En los bucles for...of, se puede causar que la iteración termine de un modo brusco usando: break, continue[4], throw or return[5]. En estos casos la iteración se cierra.
-
-function* foo(){
- yield 1;
- yield 2;
- yield 3;
-};
-
-for (let o of foo()) {
- console.log(o);
- break; // closes iterator, triggers return
-}
-
-Iterando generadores
-
-También es posible iterar las nuevas funciones generator:
-
-function* fibonacci() { // una función generador
- let [prev, curr] = [0, 1];
- while (true) {
- [prev, curr] = [curr, prev + curr];
- yield curr;
- }
-}
-
-for (let n of fibonacci()) {
- console.log(n);
- // interrumpir la secuencia en 1000
- if (n >= 1000) {
- break;
- }
-}
-
-
-
-
-
Los generadores no deben ser reutilizados, incluso si el bucle for...of se ha terminado antes de tiempo con la sentencia break. Una vez abandonado el bucle, el generador está cerrado y tratar de iterar sobre él de nuevo no dará más resultados. Firefox no ha implementado aún este comportamiento y el generador puede ser reutilizado en contra de lo escrito en el estándar ES6 (13.7.5.13, step 5m), pero esto cambiará una vez que el bug {{Bug(1147371)}} haya sido corregido.
-
var gen = (function *(){
- yield 1;
- yield 2;
- yield 3;
-})();
-for (let o of gen) {
- console.log(o);
- break; // Finaliza la iteración
-}
-
-// El generador no debe ser reutilizado, lo siguiente no tiene sentido
-for (let o of gen) {
- console.log(o); // Nunca será llamado
-}
-
-Iterando otros objetos iterables
-
-Es posible, además, iterar un objeto que explicitamente implemente el protocolo iterable:
-
-var iterable = {
- [Symbol.iterator]() {
- return {
- i: 0,
- next() {
- if (this.i < 3) {
- return { value: this.i++, done: false };
- }
- return { value: undefined, done: true };
- }
- };
- }
-};
-
-for (var value of iterable) {
- console.log(value);
-}
-// 0
-// 1
-// 2
-
-Diferencia entre for...of y for...in
-
-El bucle for...in iterará sobre todas las propiedades de un objeto. Más tecnicamente, iterará sobre cualquier propiedad en el objeto que haya sido internamente definida con su propiedad [[Enumerable]] configurada como true.
-
-La sintaxis de for...of es específica para las colecciones, y no para todos los objetos. Esta Iterará sobre cualquiera de los elementos de una colección que tengan la propiedad [Symbol.iterator].
-
-El siguiente ejemplo muestra las diferencias entre un bucle for...of y un bucle for...in.
-
-let arr = [3, 5, 7];
-arr.foo = "hola";
-
-for (let i in arr) {
- console.log(i); // logs "0", "1", "2", "foo"
-}
-
-for (let i of arr) {
- console.log(i); // logs "3", "5", "7"
-}
-
-Especificaciones
-
-
-
-
- | Especificación |
- Estado |
- Cometario |
-
-
- | {{SpecName('ES6', '#sec-for-in-and-for-of-statements', 'for...of statement')}} |
- {{Spec2('ES6')}} |
- Definición inicial. |
-
-
- | {{SpecName('ESDraft', '#sec-for-in-and-for-of-statements', 'for...of statement')}} |
- {{Spec2('ESDraft')}} |
- |
-
-
-
-
-Compatibilidad de navegadores
-
-{{Compat("javascript.statements.for_of")}}
-
-Vea también
-
-
- - {{jsxref("Array.prototype.forEach()")}}
- - {{jsxref("Map.prototype.forEach()")}}
-
diff --git a/files/es/web/javascript/reference/statements/for...of/index.md b/files/es/web/javascript/reference/statements/for...of/index.md
new file mode 100644
index 00000000000000..98cc17fe77967e
--- /dev/null
+++ b/files/es/web/javascript/reference/statements/for...of/index.md
@@ -0,0 +1,260 @@
+---
+title: for...of
+slug: Web/JavaScript/Reference/Statements/for...of
+tags:
+ - ECMAScript6
+ - JavaScript
+ - Referencia
+ - Sentencia
+translation_of: Web/JavaScript/Reference/Statements/for...of
+original_slug: Web/JavaScript/Referencia/Sentencias/for...of
+---
+{{jsSidebar("Statements")}}
+
+La sentencia **sentencia `for...of`** ejecuta un bloque de código para cada elemento de un [objeto iterable](/es/docs/Web/JavaScript/Guide/iterable), como lo son: {{jsxref("String")}}, {{jsxref("Array")}}, objetos similares a array (por ejemplo, {{jsxref("Functions/arguments", "arguments")}} or [`NodeList`](/es/docs/Web/API/NodeList "NodeList objects are collections of nodes, usually returned by properties such as Node.childNodes and methods such as document.querySelectorAll().")), {{jsxref("TypedArray")}}, {{jsxref("Map")}}, {{jsxref("Set")}} e iterables definidos por el usuario.
+
+## Sintaxis
+
+ for (variable of iterable) {
+ statement
+ }
+
+- `variable`
+ - : En cada iteración el elemento (propiedad enumerable) correspondiente es asignado a _variable_.
+- `iterable`
+ - : Objeto cuyas propiedades enumerables son iteradas.
+
+## Ejemplos
+
+### Iterando un {{jsxref("Array")}}
+
+```js
+let iterable = [10, 20, 30];
+
+for (let value of iterable) {
+ value += 1;
+ console.log(value);
+}
+// 11
+// 21
+// 31
+```
+
+Es posible usar `const` en lugar de `let `si no se va a modificar la variable dentro del bloque.
+
+```js
+let iterable = [10, 20, 30];
+
+for (const value of iterable) {
+ console.log(value);
+}
+// 10
+// 20
+// 30
+```
+
+### Iterando un {{jsxref("String")}}
+
+```js
+let iterable = "boo";
+
+for (let value of iterable) {
+ console.log(value);
+}
+// "b"
+// "o"
+// "o"
+```
+
+### Iterando un {{jsxref("TypedArray")}}
+
+```js
+let iterable = new Uint8Array([0x00, 0xff]);
+
+for (let value of iterable) {
+ console.log(value);
+}
+// 0
+// 255
+```
+
+### Iterando un {{jsxref("Map")}}
+
+```js
+let iterable = new Map([["a", 1], ["b", 2], ["c", 3]]);
+
+for (let entry of iterable) {
+ console.log(entry);
+}
+// ['a', 1]
+// ['b', 2]
+// ['c', 3]
+
+for (let [key, value] of iterable) {
+ console.log(value);
+}
+// 1
+// 2
+// 3
+```
+
+### Iterando un {{jsxref("Set")}}
+
+```js
+let iterable = new Set([1, 1, 2, 2, 3, 3]);
+
+for (let value of iterable) {
+ console.log(value);
+}
+// 1
+// 2
+// 3
+```
+
+### Iterando un objeto [arguments](/es/docs/Web/JavaScript/Reference/Functions_and_function_scope/arguments)
+
+```js
+(function() {
+ for (let argument of arguments) {
+ console.log(argument);
+ }
+})(1, 2, 3);
+
+// 1
+// 2
+// 3
+```
+
+### Iterando una colección del DOM
+
+Iterando colecciones del DOM como un {{domxref("NodeList")}}: el siguiente ejemplo añade la clase "read" a los párrafos (``) que son descendientes directos de un (``):
+
+```js
+// Nota: Esto solo funcionará en plataformas que tengan
+// implementado NodeList.prototype[Symbol.iterator]
+let articleParagraphs = document.querySelectorAll("article > p");
+
+for (let paragraph of articleParagraphs) {
+ paragraph.classList.add("read");
+}
+```
+
+### Clausurando iteraciones
+
+En los bucles `for...of`, se puede causar que la iteración termine de un modo brusco usando: `break`, `continue[4]`, `throw` or `return[5]`. En estos casos la iteración se cierra.
+
+ function* foo(){
+ yield 1;
+ yield 2;
+ yield 3;
+ };
+
+ for (let o of foo()) {
+ console.log(o);
+ break; // closes iterator, triggers return
+ }
+
+### Iterando generadores
+
+También es posible iterar las nuevas funciones **[generator](/es/docs/Web/JavaScript/Reference/Statements/function*)**:
+
+```js
+function* fibonacci() { // una función generador
+ let [prev, curr] = [0, 1];
+ while (true) {
+ [prev, curr] = [curr, prev + curr];
+ yield curr;
+ }
+}
+
+for (let n of fibonacci()) {
+ console.log(n);
+ // interrumpir la secuencia en 1000
+ if (n >= 1000) {
+ break;
+ }
+}
+```
+
+> **Nota:** **No se deben reutilizar los generadores** Los generadores no deben ser reutilizados, incluso si el bucle **`for...of`** se ha terminado antes de tiempo con la sentencia [break](/es/docs/Web/JavaScript/Referencia/Sentencias/break). Una vez abandonado el bucle, el generador está cerrado y tratar de iterar sobre él de nuevo no dará más resultados. Firefox no ha implementado aún este comportamiento y el generador puede ser reutilizado en contra de lo escrito en el estándar ES6 ([13.7.5.13, step 5m](https://www.ecma-international.org/ecma-262/6.0/#sec-13.7.5.13)), pero esto cambiará una vez que el bug {{Bug(1147371)}} haya sido corregido.
+
+```js example-bad
+var gen = (function *(){
+ yield 1;
+ yield 2;
+ yield 3;
+})();
+for (let o of gen) {
+ console.log(o);
+ break; // Finaliza la iteración
+}
+
+// El generador no debe ser reutilizado, lo siguiente no tiene sentido
+for (let o of gen) {
+ console.log(o); // Nunca será llamado
+}
+```
+
+### Iterando otros objetos iterables
+
+Es posible, además, iterar un objeto que explicitamente implemente el protocolo [iterable](/es/docs/Web/JavaScript/Reference/Iteration_protocols#iterable):
+
+```js
+var iterable = {
+ [Symbol.iterator]() {
+ return {
+ i: 0,
+ next() {
+ if (this.i < 3) {
+ return { value: this.i++, done: false };
+ }
+ return { value: undefined, done: true };
+ }
+ };
+ }
+};
+
+for (var value of iterable) {
+ console.log(value);
+}
+// 0
+// 1
+// 2
+```
+
+### Diferencia entre `for...of` y `for...in`
+
+El bucle `for...in iterará sobre todas las propiedades de un objeto.` Más tecnicamente, iterará sobre cualquier propiedad en el objeto que haya sido internamente definida con su propiedad `[[Enumerable]] `configurada como `true`.
+
+La sintaxis de **`for...of`** es específica para las **colecciones**, y no para todos los objetos. Esta Iterará sobre cualquiera de los elementos de una colección que tengan la propiedad `[Symbol.iterator]`.
+
+El siguiente ejemplo muestra las diferencias entre un bucle **`for...of`** y un bucle **f`or...in`**.
+
+```js
+let arr = [3, 5, 7];
+arr.foo = "hola";
+
+for (let i in arr) {
+ console.log(i); // logs "0", "1", "2", "foo"
+}
+
+for (let i of arr) {
+ console.log(i); // logs "3", "5", "7"
+}
+```
+
+## Especificaciones
+
+| Especificación | Estado | Cometario |
+| ------------------------------------------------------------------------------------------------------------ | ---------------------------- | ------------------- |
+| {{SpecName('ES6', '#sec-for-in-and-for-of-statements', 'for...of statement')}} | {{Spec2('ES6')}} | Definición inicial. |
+| {{SpecName('ESDraft', '#sec-for-in-and-for-of-statements', 'for...of statement')}} | {{Spec2('ESDraft')}} | |
+
+## Compatibilidad de navegadores
+
+{{Compat("javascript.statements.for_of")}}
+
+## Vea también
+
+- {{jsxref("Array.prototype.forEach()")}}
+- {{jsxref("Map.prototype.forEach()")}}
diff --git a/files/es/web/javascript/reference/statements/for/index.html b/files/es/web/javascript/reference/statements/for/index.html
deleted file mode 100644
index 8cb0c1131f9933..00000000000000
--- a/files/es/web/javascript/reference/statements/for/index.html
+++ /dev/null
@@ -1,58 +0,0 @@
----
-title: for
-slug: Web/JavaScript/Reference/Statements/for
-tags:
- - JavaScript
- - Statement
-translation_of: Web/JavaScript/Reference/Statements/for
-original_slug: Web/JavaScript/Referencia/Sentencias/for
----
-
- {{jsSidebar("Statements")}}
-Resumen
-Crea un bucle que consiste en tres expresiones opcionales, encerradas en paréntesis y separadas por puntos y comas, seguidas de una sentencia ejecutada en un bucle.
-Sintaxis
-for ([expresion-inicial]; [condicion]; [expresion-final])sentencia
-
-
- -
-
expresion-inicial
- -
- Una expresión (incluyendo las expresiones de asignación) o la declaración de variable. Típicamente se utiliza para usarse como variable contador. Esta expresión puede opcionalmente declarar nuevas variables con la palabra clave
var. Estas variables no son locales del bucle, es decir, están en el mismo alcance en el que está el bucle for. El resultado de esta expresión es descartado.
-
-
- -
-
condicion
- -
- Una expresión para ser evaluada antes de cada iteración del bucle. Si esta expresión se evalúa como verdadera, se ejecuta
sentencia. Esta comprobación condicional es opcional. Si se omite, la condición siempre se evalúa como verdadera. Si la expresión se evalúa como falsa, la ejecución salta a la primera expresión que sigue al constructor de for.
-
-
- -
-
expresion-final
- -
- Una expresión para ser evaluada al final de cada iteración del bucle. Esto ocurre antes de la siguiente evaluación de la
condicion. Generalmente se usa para actualizar o incrementar la variable contador.
-
-
- -
-
sentencia
- -
- Una sentencia que se ejecuta mientras la condición se evalúa como verdadera. Para ejecutar múltiples sentencias dentro del bucle, utilice una sentencia {{jsxref("Sentencias/block", "block")}} (
{ ... }) para agrupar aquellas sentecias.
-
-Ejemplos
-Ejemplo: Usando for
-La siguiente sentencia for comienza mediante la declaración de la variable i y se inicializa a 0. Comprueba que i es menor que nueve, realiza las dos sentencias con éxito e incrementa i en 1 después de cada pase del bucle.
-for (var i = 0; i < 9; i++) {
- n += i;
- mifuncion(n);
-}
-
-Vea También
-
- - {{jsxref("Sentencias/break", "break")}}
- - {{jsxref("Sentencias/continue", "continue")}}
- - {{jsxref("Sentencias/empty", "empty")}}
- - {{jsxref("Sentencias/while", "while")}}
- - {{jsxref("Sentencias/do...while", "do...while")}}
- - {{jsxref("Sentencias/for...in", "for...in")}}
- - {{jsxref("Sentencias/for...of", "for...of")}}
-
diff --git a/files/es/web/javascript/reference/statements/for/index.md b/files/es/web/javascript/reference/statements/for/index.md
new file mode 100644
index 00000000000000..6fb878f6d6ed5c
--- /dev/null
+++ b/files/es/web/javascript/reference/statements/for/index.md
@@ -0,0 +1,51 @@
+---
+title: for
+slug: Web/JavaScript/Reference/Statements/for
+tags:
+ - JavaScript
+ - Statement
+translation_of: Web/JavaScript/Reference/Statements/for
+original_slug: Web/JavaScript/Referencia/Sentencias/for
+---
+{{jsSidebar("Statements")}}
+
+## Resumen
+
+Crea un bucle que consiste en tres expresiones opcionales, encerradas en paréntesis y separadas por puntos y comas, seguidas de una sentencia ejecutada en un bucle.
+
+## Sintaxis
+
+ for ([expresion-inicial]; [condicion]; [expresion-final])sentencia
+
+- `expresion-inicial`
+ - : Una expresión (incluyendo las expresiones de asignación) o la declaración de variable. Típicamente se utiliza para usarse como variable contador. Esta expresión puede opcionalmente declarar nuevas variables con la palabra clave `var`. Estas variables no son locales del bucle, es decir, están en el mismo alcance en el que está el bucle `for`. El resultado de esta expresión es descartado.
+
+- `condicion`
+ - : Una expresión para ser evaluada antes de cada iteración del bucle. Si esta expresión se evalúa como verdadera, se ejecuta `sentencia`. Esta comprobación condicional es opcional. Si se omite, la condición siempre se evalúa como verdadera. Si la expresión se evalúa como falsa, la ejecución salta a la primera expresión que sigue al constructor de `for`.
+
+- `expresion-final`
+ - : Una expresión para ser evaluada al final de cada iteración del bucle. Esto ocurre antes de la siguiente evaluación de la `condicion`. Generalmente se usa para actualizar o incrementar la variable contador.
+
+- `sentencia`
+ - : Una sentencia que se ejecuta mientras la condición se evalúa como verdadera. Para ejecutar múltiples sentencias dentro del bucle, utilice una sentencia {{jsxref("Sentencias/block", "block")}} (`{ ... }`) para agrupar aquellas sentecias.
+
+### Ejemplos
+
+#### Ejemplo: Usando `for`
+
+La siguiente sentencia `for` comienza mediante la declaración de la variable `i` y se inicializa a `0`. Comprueba que `i` es menor que nueve, realiza las dos sentencias con éxito e incrementa `i` en 1 después de cada pase del bucle.
+
+ for (var i = 0; i < 9; i++) {
+ n += i;
+ mifuncion(n);
+ }
+
+## Vea También
+
+- {{jsxref("Sentencias/break", "break")}}
+- {{jsxref("Sentencias/continue", "continue")}}
+- {{jsxref("Sentencias/empty", "empty")}}
+- {{jsxref("Sentencias/while", "while")}}
+- {{jsxref("Sentencias/do...while", "do...while")}}
+- {{jsxref("Sentencias/for...in", "for...in")}}
+- {{jsxref("Sentencias/for...of", "for...of")}}
diff --git a/files/es/web/javascript/reference/statements/function/index.html b/files/es/web/javascript/reference/statements/function/index.html
deleted file mode 100644
index 675b8da2f260d8..00000000000000
--- a/files/es/web/javascript/reference/statements/function/index.html
+++ /dev/null
@@ -1,53 +0,0 @@
----
-title: function
-slug: Web/JavaScript/Reference/Statements/function
-tags:
- - JavaScript
- - Statement
-translation_of: Web/JavaScript/Reference/Statements/function
-original_slug: Web/JavaScript/Referencia/Sentencias/function
----
-
- {{jsSidebar("Statements")}}
-Resumen
-Declara una función con los parámetros especificados.
-Puede también definir funciones usando el constructor {{jsxref("Function")}} y el {{jsxref("Operadors/function", "function")}} (expresión function).
-Sintaxis
-function nombre([parametro1] [,parametro2] [..., parametroN]) {sentencias}
-
-
- -
-
nombre
- -
- El nombre de la función.
-
-
- -
-
parametroN
- -
- El nombre de un argumento que se pasa a la función. Una función puede tener hasta 255 argumentos.
-
-
- -
-
sentencias
- -
- Las sentencias que comprenden el cuerpo de la función.
-
-Descripción
-Para devolver un valor, la función debe tener una sentencia {{jsxref("Sentencias/return", "return")}} que especifica el valor a devolver.
-Una función creada con la sentencia function es un objeto Function y tiene todas las propiedades, métodos, y comportamiento de los objetos Function. Vea {{jsxref("Function")}} para información detallada sobre funciones.
-Una función puede también ser declarada dentro de una expresión. En este caso la función es normalmente anónima. Vea {{jsxref("Operadores/function", "function expression")}} para más información acerca de function (expresión function).
-Las funciones pueden declararse condicionalmente. Es decir, una definición de una función puede estar anidada dentro de una sentecia if. Técnicamente, tales declaraciones no son en realidad declaraciones de funciones; son expresiones function (expresiones de función).
-Ejemplo
-Ejemplo: Usando function
-El siguiente código declara una función que devuelve la cantidad total de ventas, cuando se da el número de unidades vendidas de productos a, b, y c.
-function calcular_ventas(unidades_a, unidades_b, unidades_c) {
- return unidades_a*79 + unidades_b * 129 + unidades_c * 699;
-}
-
-Vea También
-
- - Funciones
- - {{jsxref("Function")}}
- - Operadores{{jsxref("Operadores/function", "function")}}
-
diff --git a/files/es/web/javascript/reference/statements/function/index.md b/files/es/web/javascript/reference/statements/function/index.md
new file mode 100644
index 00000000000000..d1a8fcd30f251d
--- /dev/null
+++ b/files/es/web/javascript/reference/statements/function/index.md
@@ -0,0 +1,57 @@
+---
+title: function
+slug: Web/JavaScript/Reference/Statements/function
+tags:
+ - JavaScript
+ - Statement
+translation_of: Web/JavaScript/Reference/Statements/function
+original_slug: Web/JavaScript/Referencia/Sentencias/function
+---
+{{jsSidebar("Statements")}}
+
+## Resumen
+
+Declara una función con los parámetros especificados.
+
+Puede también definir funciones usando el constructor {{jsxref("Function")}} y el {{jsxref("Operadors/function", "function")}} (expresión function).
+
+## Sintaxis
+
+ function nombre([parametro1] [,parametro2] [..., parametroN]) {sentencias}
+
+- `nombre`
+ - : El nombre de la función.
+
+- `parametroN`
+ - : El nombre de un argumento que se pasa a la función. Una función puede tener hasta 255 argumentos.
+
+- `sentencias`
+ - : Las sentencias que comprenden el cuerpo de la función.
+
+## Descripción
+
+Para devolver un valor, la función debe tener una sentencia {{jsxref("Sentencias/return", "return")}} que especifica el valor a devolver.
+
+Una función creada con la sentencia `function` es un objeto `Function` y tiene todas las propiedades, métodos, y comportamiento de los objetos `Function`. Vea {{jsxref("Function")}} para información detallada sobre funciones.
+
+Una función puede también ser declarada dentro de una expresión. En este caso la función es normalmente anónima. Vea {{jsxref("Operadores/function", "function expression")}} para más información acerca de `function` (expresión function).
+
+Las funciones pueden declararse condicionalmente. Es decir, una definición de una función puede estar anidada dentro de una sentecia `if`. Técnicamente, tales declaraciones no son en realidad declaraciones de funciones; son expresiones function (expresiones de función).
+
+## Ejemplo
+
+### Ejemplo: Usando `function`
+
+El siguiente código declara una función que devuelve la cantidad total de ventas, cuando se da el número de unidades vendidas de productos `a`, `b`, y `c`.
+
+```js
+function calcular_ventas(unidades_a, unidades_b, unidades_c) {
+ return unidades_a*79 + unidades_b * 129 + unidades_c * 699;
+}
+```
+
+## Vea También
+
+- [Funciones](/es/docs/Web/JavaScript/Referencia/Funciones)
+- {{jsxref("Function")}}
+- Operadores{{jsxref("Operadores/function", "function")}}
diff --git a/files/es/web/javascript/reference/statements/function_star_/index.html b/files/es/web/javascript/reference/statements/function_star_/index.html
deleted file mode 100644
index af20ab4d24086b..00000000000000
--- a/files/es/web/javascript/reference/statements/function_star_/index.html
+++ /dev/null
@@ -1,133 +0,0 @@
----
-title: function*
-slug: Web/JavaScript/Reference/Statements/function*
-tags:
- - Declaración
- - Experimental
- - Expérimental(2)
- - Iterador
- - función
-translation_of: Web/JavaScript/Reference/Statements/function*
-original_slug: Web/JavaScript/Referencia/Sentencias/function*
----
-{{jsSidebar("Statements")}}
-
-La declaración function* (la palabra clave function seguida de un asterisco) define una función generadora, que devuelve un objeto {{jsxref("Global_Objects/Generator","Generator")}}.
-
-
-
También puedes definir funciones generadoras usando el constructor {{jsxref("GeneratorFunction")}} y una {{jsxref("Operators/function*", "function* expression")}}.
-
Sintaxis
-
-function* nombre([param[, param[, ... param]]]) {
- instrucciones
-}
-
-
-
- nombre- El nombre de la función.
-
-
-
- param- El nombre de los argumentos que se le van a pasar a la función. Una función puede tener hasta 255 argumentos.
-
-
-
- instrucciones- Las instrucciones que componen el cuerpo de la función.
-
-
-Descripción
-
-Los generadores son funciones de las que se puede salir y volver a entrar. Su contexto (asociación de variables) será conservado entre las reentradas.
-
-La llamada a una función generadora no ejecuta su cuerpo inmediatamente; se devuelve un objeto iterador para la función en su lugar. Cuando el metodo next() del iterador es llamado , el cuerpo de la función generadora es ejecutado hasta la primera expresión {{jsxref("Operators/yield", "yield")}}, la cual especifica el valor que será retornado por el iterador o con, {{jsxref("Operators/yield*", "yield*")}}, delega a otra función generadora. El método next() retorna un objeto con una propiedad value que contiene el valor bajo el operador yield y una propiedad done que indica, con un booleano, si la función generadora ha hecho yield al último valor.
-
-Ejemplos
-
-Ejemplo simple
-
-function* idMaker(){
- var index = 0;
- while(index < 3)
- yield index++;
-}
-
-var gen = idMaker();
-
-console.log(gen.next().value); // 0
-console.log(gen.next().value); // 1
-console.log(gen.next().value); // 2
-console.log(gen.next().value); // undefined
-// ...
-
-Ejemplo con yield*
-
-function* anotherGenerator(i) {
- yield i + 1;
- yield i + 2;
- yield i + 3;
-}
-
-function* generator(i){
- yield i;
- yield* anotherGenerator(i);
- yield i + 10;
-}
-
-var gen = generator(10);
-
-console.log(gen.next().value); // 10
-console.log(gen.next().value); // 11
-console.log(gen.next().value); // 12
-console.log(gen.next().value); // 13
-console.log(gen.next().value); // 20
-
-
-Especificaciones
-
-
-
-
- | Especificaciones |
- Status |
- Comentarios |
-
-
-
-
- | {{SpecName('ES2015', '#', 'function*')}} |
- {{Spec2('ES2015')}} |
- Initial definition. |
-
-
-
-
-Compatibilidad con navegadores
-
-{{Compat("javascript.statements.generator_function")}}
-
-Ver también
-
-
- - {{jsxref("Operators/function*", "function* expression")}}
- - {{jsxref("GeneratorFunction")}} object
- - The Iterator protocol
- - {{jsxref("Operators/yield", "yield")}}
- - {{jsxref("Operators/yield*", "yield*")}}
- - {{jsxref("Function")}} object
- - {{jsxref("Statements/function", "function declaration")}}
- - {{jsxref("Operators/function", "function expression")}}
- - {{jsxref("Functions_and_function_scope", "Functions and function scope")}}
- - Other web resources:
-
-
-
diff --git a/files/es/web/javascript/reference/statements/function_star_/index.md b/files/es/web/javascript/reference/statements/function_star_/index.md
new file mode 100644
index 00000000000000..83435385581591
--- /dev/null
+++ b/files/es/web/javascript/reference/statements/function_star_/index.md
@@ -0,0 +1,110 @@
+---
+title: function*
+slug: Web/JavaScript/Reference/Statements/function*
+tags:
+ - Declaración
+ - Experimental
+ - Expérimental(2)
+ - Iterador
+ - función
+translation_of: Web/JavaScript/Reference/Statements/function*
+original_slug: Web/JavaScript/Referencia/Sentencias/function*
+---
+{{jsSidebar("Statements")}}
+
+La declaración **`function*`** (la palabra clave `function` seguida de un asterisco) define una _función generadora_, que devuelve un objeto {{jsxref("Global_Objects/Generator","Generator")}}.
+
+También puedes definir funciones generadoras usando el constructor {{jsxref("GeneratorFunction")}} y una {{jsxref("Operators/function*", "function* expression")}}.
+
+## Sintaxis
+
+ function* nombre([param[, param[, ... param]]]) {
+ instrucciones
+ }
+
+- `nombre`
+ - : El nombre de la función.
+
+- `param`
+ - : El nombre de los argumentos que se le van a pasar a la función. Una función puede tener hasta 255 argumentos.
+
+- `instrucciones`
+ - : Las instrucciones que componen el cuerpo de la función.
+
+## Descripción
+
+Los generadores son funciones de las que se puede salir y volver a entrar. Su contexto (asociación de variables) será conservado entre las reentradas.
+
+La llamada a una función generadora no ejecuta su cuerpo inmediatamente; se devuelve un objeto [iterador](/es/docs/Web/JavaScript/Reference/Iteration_protocols#iterator) para la función en su lugar. Cuando el metodo `next()` del iterador es llamado , el cuerpo de la función generadora es ejecutado hasta la primera expresión {{jsxref("Operators/yield", "yield")}}, la cual especifica el valor que será retornado por el iterador o con, {{jsxref("Operators/yield*", "yield*")}}, delega a otra función generadora. El método `next()` retorna un objeto con una propiedad _value_ que contiene el valor bajo el operador yield y una propiedad _done_ que indica, con un booleano, si la función generadora ha hecho yield al último valor.
+
+## Ejemplos
+
+### Ejemplo simple
+
+```js
+function* idMaker(){
+ var index = 0;
+ while(index < 3)
+ yield index++;
+}
+
+var gen = idMaker();
+
+console.log(gen.next().value); // 0
+console.log(gen.next().value); // 1
+console.log(gen.next().value); // 2
+console.log(gen.next().value); // undefined
+// ...
+```
+
+### Ejemplo con yield\*
+
+```js
+function* anotherGenerator(i) {
+ yield i + 1;
+ yield i + 2;
+ yield i + 3;
+}
+
+function* generator(i){
+ yield i;
+ yield* anotherGenerator(i);
+ yield i + 10;
+}
+
+var gen = generator(10);
+
+console.log(gen.next().value); // 10
+console.log(gen.next().value); // 11
+console.log(gen.next().value); // 12
+console.log(gen.next().value); // 13
+console.log(gen.next().value); // 20
+```
+
+## Especificaciones
+
+| Especificaciones | Status | Comentarios |
+| ---------------------------------------------------- | ------------------------ | ------------------- |
+| {{SpecName('ES2015', '#', 'function*')}} | {{Spec2('ES2015')}} | Initial definition. |
+
+## Compatibilidad con navegadores
+
+{{Compat("javascript.statements.generator_function")}}
+
+## Ver también
+
+- {{jsxref("Operators/function*", "function* expression")}}
+- {{jsxref("GeneratorFunction")}} object
+- [The Iterator protocol](/es/docs/Web/JavaScript/Guide/The_Iterator_protocol)
+- {{jsxref("Operators/yield", "yield")}}
+- {{jsxref("Operators/yield*", "yield*")}}
+- {{jsxref("Function")}} object
+- {{jsxref("Statements/function", "function declaration")}}
+- {{jsxref("Operators/function", "function expression")}}
+- {{jsxref("Functions_and_function_scope", "Functions and function scope")}}
+- Other web resources:
+
+ - [Regenerator](http://facebook.github.io/regenerator/) an ES2015 generator compiler to ES5
+ - [Forbes Lindesay: Promises and Generators: control flow utopia -- JSConf EU 2013](http://www.youtube.com/watch?v=qbKWsbJ76-s)
+ - [Hemanth.HM: The New gen of \*gen(){}](https://www.youtube.com/watch?v=ZrgEZykBHVo&list=PLuoyIZT5fPlG44bPq50Wgh0INxykdrYX7&index=1)
+ - [Task.js](http://taskjs.org/)
diff --git a/files/es/web/javascript/reference/statements/if...else/index.html b/files/es/web/javascript/reference/statements/if...else/index.html
deleted file mode 100644
index 32a044324f6605..00000000000000
--- a/files/es/web/javascript/reference/statements/if...else/index.html
+++ /dev/null
@@ -1,110 +0,0 @@
----
-title: if...else
-slug: Web/JavaScript/Reference/Statements/if...else
-tags:
- - JavaScript
- - Statement
-translation_of: Web/JavaScript/Reference/Statements/if...else
-original_slug: Web/JavaScript/Referencia/Sentencias/if...else
----
-{{jsSidebar("Statements")}}
-
-Resumen
-
-Ejecuta una sentencia si una condición específicada es evaluada como verdadera. Si la condición es evaluada como falsa, otra sentencia puede ser ejecutada.
-
-Sintaxis
-
-if (condición) sentencia1 [else sentencia2]
-
-
-
- condición- Una expresión que puede ser evaluada como verdadera o falsa.
-
-
-
- sentencia1- Sentencia que se ejecutará si
condición es evaluada como verdadera. Puede ser cualquier sentencia, incluyendo otras sentenccias if anidadas. Para ejecutar múltiples sentencias, use una sentencia {{jsxref("Sentencias/block", "block")}} ({ ... }) para agruparlas.
-
-
-
- sentencia2- Sentencia que se ejecutará si
condición se evalúa como falsa, y exista una cláusula else. Puede ser cualquier sentencia, incluyendo sentencias block y otras sentencias if anidadas.
-
-
-Descripción
-
-Multiples sentencias if...else pueden ser anidadas para crear una cláusula else if:
-
-if (condición1)
- sentencia1
-else if (condición2)
- sentencia2
-else if (condición3)
- sentencia3
-...
-else
- sentenciaN
-
-
-Para entender como esto funciona, así es como se vería si el anidamiento hubiera sido indentado correctamente:
-
-if (condición1)
- sentencia1
-else
- if (condición2)
- sentencia2
- else
- if (condición3)
- ...
-
-
-Para ejecutar varias sentencias en una cláusula, use una sentencia block ({ ... }) para agruparlas. Generalmente, es una buena práctica usar siempre sentencias block, especialmente en código que incluya sentencias if anidadas:
-
-if (condición) {
- sentencia1
-} else {
- sentencia2
-}
-
-
-No confundir los valores primitivos true y false con los valores true y false del objeto {{jsxref("Boolean")}}. Cualquier valor diferente de undefined, null, 0, -0, NaN, o la cadena vacía (""), y cualquier objecto, incluso un objeto Boolean cuyo valor es false, se evalúa como verdadero en una sentencia condicional. Por ejemplo:
-
-var b = new Boolean(false);
-if (b) // Esta condición se evalúa como verdadera
-
-
-Ejemplos
-
-Ejemplo: Uso de if...else
-
-if (cipher_char == from_char) {
- result = result + to_char;
- x++;
-} else
- result = result + clear_char;
-
-
-Ejemplo: Asignación en una expresión condicional
-
-Es aconsejable no usar asignaciones simples en una expresión condicional, porque la asignación puede ser confundida con igualdad (operador relacional) cuando se lee el código. Por ejemplo, no use el siguiente código:
-
-if (x = y) {
- /* sentencia */
-}
-
-
-Si realmente necesita una asignación dentro de una exprsión condicional, una práctica común es poner paréntesis adicionales alrededor del la asignación, por ejemplo:
-
-if ((x = y)) {
- /* sentencia */
-}
-
-
-Vea También
-
-
- - {{jsxref("Sentencias/block", "block")}}
- - {{jsxref("Sentencias/switch", "switch")}}
-
diff --git a/files/es/web/javascript/reference/statements/if...else/index.md b/files/es/web/javascript/reference/statements/if...else/index.md
new file mode 100644
index 00000000000000..ebe076f690041b
--- /dev/null
+++ b/files/es/web/javascript/reference/statements/if...else/index.md
@@ -0,0 +1,104 @@
+---
+title: if...else
+slug: Web/JavaScript/Reference/Statements/if...else
+tags:
+ - JavaScript
+ - Statement
+translation_of: Web/JavaScript/Reference/Statements/if...else
+original_slug: Web/JavaScript/Referencia/Sentencias/if...else
+---
+{{jsSidebar("Statements")}}
+
+## Resumen
+
+Ejecuta una sentencia si una condición específicada es evaluada como verdadera. Si la condición es evaluada como falsa, otra sentencia puede ser ejecutada.
+
+## Sintaxis
+
+ if (condición) sentencia1 [else sentencia2]
+
+- `condición`
+ - : Una expresión que puede ser evaluada como verdadera o falsa.
+
+- `sentencia1`
+ - : Sentencia que se ejecutará si `condición` es evaluada como verdadera. Puede ser cualquier sentencia, incluyendo otras sentenccias `if` anidadas. Para ejecutar múltiples sentencias, use una sentencia {{jsxref("Sentencias/block", "block")}} ({ ... }) para agruparlas.
+
+- `sentencia2`
+ - : Sentencia que se ejecutará si `condición` se evalúa como falsa, y exista una cláusula `else`. Puede ser cualquier sentencia, incluyendo sentencias block y otras sentencias `if` anidadas.
+
+## Descripción
+
+Multiples sentencias `if...else` pueden ser anidadas para crear una cláusula `else if`:
+
+ if (condición1)
+ sentencia1
+ else if (condición2)
+ sentencia2
+ else if (condición3)
+ sentencia3
+ ...
+ else
+ sentenciaN
+
+Para entender como esto funciona, así es como se vería si el anidamiento hubiera sido indentado correctamente:
+
+ if (condición1)
+ sentencia1
+ else
+ if (condición2)
+ sentencia2
+ else
+ if (condición3)
+ ...
+
+Para ejecutar varias sentencias en una cláusula, use una sentencia block (`{ ... }`) para agruparlas. Generalmente, es una buena práctica usar siempre sentencias block, especialmente en código que incluya sentencias if anidadas:
+
+```js
+if (condición) {
+ sentencia1
+} else {
+ sentencia2
+}
+```
+
+No confundir los valores primitivos `true` y `false` con los valores true y false del objeto {{jsxref("Boolean")}}. Cualquier valor diferente de `undefined`, `null`, `0`, `-0`, `NaN`, o la cadena vacía (`""`), y cualquier objecto, incluso un objeto Boolean cuyo valor es false, se evalúa como verdadero en una sentencia condicional. Por ejemplo:
+
+```js
+var b = new Boolean(false);
+if (b) // Esta condición se evalúa como verdadera
+```
+
+## Ejemplos
+
+### Ejemplo: Uso de `if...else`
+
+```js
+if (cipher_char == from_char) {
+ result = result + to_char;
+ x++;
+} else
+ result = result + clear_char;
+```
+
+### Ejemplo: Asignación en una expresión condicional
+
+Es aconsejable no usar asignaciones simples en una expresión condicional, porque la asignación puede ser confundida con igualdad (operador relacional) cuando se lee el código. Por ejemplo, no use el siguiente código:
+
+```js
+if (x = y) {
+ /* sentencia */
+}
+```
+
+Si realmente necesita una asignación dentro de una exprsión condicional, una práctica común es poner paréntesis adicionales alrededor del la asignación, por ejemplo:
+
+```js
+if ((x = y)) {
+ /* sentencia */
+}
+```
+
+## Vea También
+
+- {{jsxref("Sentencias/block", "block")}}
+- {{jsxref("Sentencias/switch", "switch")}}
diff --git a/files/es/web/javascript/reference/statements/index.html b/files/es/web/javascript/reference/statements/index.html
deleted file mode 100644
index bd6ef1f8368f3b..00000000000000
--- a/files/es/web/javascript/reference/statements/index.html
+++ /dev/null
@@ -1,142 +0,0 @@
----
-title: Sentencias
-slug: Web/JavaScript/Reference/Statements
-tags:
- - JavaScript
- - Referencia
- - sentencias
-translation_of: Web/JavaScript/Reference/Statements
-original_slug: Web/JavaScript/Referencia/Sentencias
----
-{{jsSidebar("Statements")}}
-
-Las aplicaciones JavaScript se componen de sentencias con una sintaxis propia. Una sentencia puede estar formada por múltiples líneas. Puede haber varias sentencias en una sola línea si separamos cada una de las sentencias por un punto y coma. No es una palabra clave, sino un grupo de palabras clave.
-
-Sentencias y declaraciones por categoría
-
-Puedes encontrarlas por orden alfabético en la columna de la izquierda .
-
-Control de flujo
-
-
- - {{jsxref("Sentencias/block", "Block")}}
- - Un bloque de sentencias se utiliza para agrupar cero o mas sentencias. El bloque se delimita por un par de llaves.
- - {{jsxref("Sentencias/break", "break")}}
- - Finaliza la sentencia actual loop, switch, o label y transfiere el control del programa a la siguiente sentencia de la sentencia finalizada.
- - {{jsxref("Sentencias/continue", "continue")}}
- - Finaliza la ejecucion de las sentencias dentro de la iteracion actual del actual bucle, y continua la ejecucion del bucle con la siguiente iteracion.
- - {{jsxref("Sentencias/Empty", "Empty")}}
- - Una sentencia vacía se utiliza para proveer una "no sentencia", aunque la sintaxis de JavaScript esperaba una.
- - {{jsxref("Sentencias/if...else", "if...else")}}
- - Ejecuta una sentencia si una condición especificada es true. Si la condición es false, otra sentencia puede ser ejecutada.
- - {{jsxref("Sentencias/switch", "switch")}}
- - Evalua una expresión, igualando el valor de la expresión a una clausula case y ejecuta las sentencias asociadas con dicho case.
- - {{jsxref("Sentencias/throw", "throw")}}
- - Lanza una excepción definida por el usuario.
- - {{jsxref("Sentencias/try...catch", "try...catch")}}
- - Marca un bloque de sentencias para ser probadas (try) y especifica una respuesta, en caso de que se lance una excepción.
-
-
-Declaraciones
-
-
- - {{jsxref("Sentencias/var", "var")}}
- - Declara una variable, opcionalmente inicializándola a un valor.
- - {{jsxref("Sentencias/let", "let")}}
- - Declara una variable local de ambito de bloque, opcionalmente inicializándola a un valor.
- - {{jsxref("Sentencias/const", "const")}}
- - Declara una constante de solo lectura.
-
-
-Funciones
-
-
- - {{jsxref("Sentencias/function", "function")}}
- - Declara una función con los parámetros especificados.
- - {{jsxref("Sentencias/function*", "function*")}}
- - Los generadores de funciones permiten escribir {{jsxref("Iteration_protocols", "iteradores")}} con mas facilidad.
- - {{experimental_inline}} {{jsxref("Statements/async_function", "async function")}}
- - Declara una función asíncrona con los parámetros especificados.
- - {{jsxref("Statements/return", "return")}}
- - Especifica el valor a ser retornado por una función.
- - {{jsxref("Statements/class", "class")}}
- - Declara una clase.
-
-
-Iteraciones
-
-
- - {{jsxref("Sentencias/do...while", "do...while")}}
- - Crea un bucle que ejecuta una instrucción especificada hasta que la condición de prueba se evalúa como falsa. La condición se evalúa después de ejecutar la instrucción, lo que da como resultado que la instrucción especificada se ejecute al menos una vez.
- - {{jsxref("Sentencias/for", "for")}}
- - Creates a loop that consists of three optional expressions, enclosed in parentheses and separated by semicolons, followed by a statement executed in the loop.
- - {{deprecated_inline()}} {{non-standard_inline()}}{{jsxref("Sentencias/for_each...in", "for each...in")}}
- - Itera una variable especificada sobre todos los valores de las propiedades del objeto. Para cada propiedad distinta, se ejecuta una instrucción especificada.
- - {{jsxref("Sentencias/for...in", "for...in")}}
- - Itera sobre las propiedades enumerables de un objeto, en orden albitrario. Para cada propiedad distinta, las instrucciones pueden ser ejecutadas.
- - {{jsxref("Sentencias/for...of", "for...of")}}
- - Iterates over iterable objects (including {{jsxref("Array", "array")}}, array-like objects, iterators and generators), invoking a custom iteration hook with statements to be executed for the value of each distinct property.
- - {{jsxref("Sentencias/while", "while")}}
- - Crea un bucle que ejecuta la instrucción especificada siempre que la condición de prueba se evalúe como verdadera. La condición se evalúa antes de ejecutar la instrucción.
-
-
-Otros
-
-
- - {{jsxref("Sentencias/debugger", "debugger")}}
- - Invoca cualquier funcionalidad de depuración disponible. Si no hay funcionalidad de depuración disponible, esta isntrucción no tiene efecto.
- - {{jsxref("Sentencias/export", "export")}}
- - Usada para permitir a un script firmada proveer propiedades, funciones y objetos a otros scripts firmada o sin firmar. Esta antigua funcionalidad de Netscape ha sido removida y será redefinida por los modulos de ECMAScript 6
- - {{jsxref("Sentencias/import", "import")}}
- - Usada para permitir a un escript importar propiedades, funciones y objetos desde otro script firmado que ha exportado su información. Esta antigua funcionalidad de Netscape ha sido removida y será redefinida por los modulos de ECMAScript 6.
- - {{jsxref("Sentencias/label", "label")}}
- - Provee una instrucción con un identificador que puedes referir usando una instrucción
break o continue .
-
-
-
- - {{deprecated_inline()}} {{jsxref("Sentencias/with", "with")}}
- - Extiende la cadena de alcance para una instrucción.
-
-
-Especificaciones
-
-
-
-
- | Especificación |
- Status |
- Comentario |
-
-
- | {{SpecName('ES1', '#sec-12', 'Statements')}} |
- {{Spec2('ES1')}} |
- Definición inicial |
-
-
- | {{SpecName('ES3', '#sec-12', 'Statements')}} |
- {{Spec2('ES3')}} |
- |
-
-
- | {{SpecName('ES5.1', '#sec-12', 'Statements')}} |
- {{Spec2('ES5.1')}} |
- |
-
-
- | {{SpecName('ES6', '#sec-ecmascript-language-statements-and-declarations', 'ECMAScript Language: Statements and Declarations')}} |
- {{Spec2('ES6')}} |
- Nuevo: function*, let, for...of, yield, class |
-
-
- | {{SpecName('ESDraft', '#sec-ecmascript-language-statements-and-declarations', 'ECMAScript Language: Statements and Declarations')}} |
- {{Spec2('ESDraft')}} |
- |
-
-
-
-
-Vea También
-
-
diff --git a/files/es/web/javascript/reference/statements/index.md b/files/es/web/javascript/reference/statements/index.md
new file mode 100644
index 00000000000000..a25d28874f1208
--- /dev/null
+++ b/files/es/web/javascript/reference/statements/index.md
@@ -0,0 +1,101 @@
+---
+title: Sentencias
+slug: Web/JavaScript/Reference/Statements
+tags:
+ - JavaScript
+ - Referencia
+ - sentencias
+translation_of: Web/JavaScript/Reference/Statements
+original_slug: Web/JavaScript/Referencia/Sentencias
+---
+{{jsSidebar("Statements")}}
+
+Las aplicaciones JavaScript se componen de sentencias con una sintaxis propia. Una sentencia puede estar formada por múltiples líneas. Puede haber varias sentencias en una sola línea si separamos cada una de las sentencias por un punto y coma. No es una palabra clave, sino un grupo de palabras clave.
+
+## Sentencias y declaraciones por categoría
+
+Puedes encontrarlas por orden alfabético en la columna de la izquierda .
+
+### Control de flujo
+
+- {{jsxref("Sentencias/block", "Block")}}
+ - : Un bloque de sentencias se utiliza para agrupar cero o mas sentencias. El bloque se delimita por un par de llaves.
+- {{jsxref("Sentencias/break", "break")}}
+ - : Finaliza la sentencia actual loop, switch, o label y transfiere el control del programa a la siguiente sentencia de la sentencia finalizada.
+- {{jsxref("Sentencias/continue", "continue")}}
+ - : Finaliza la ejecucion de las sentencias dentro de la iteracion actual del actual bucle, y continua la ejecucion del bucle con la siguiente iteracion.
+- {{jsxref("Sentencias/Empty", "Empty")}}
+ - : Una sentencia vacía se utiliza para proveer una "no sentencia", aunque la sintaxis de JavaScript esperaba una.
+- {{jsxref("Sentencias/if...else", "if...else")}}
+ - : Ejecuta una sentencia si una condición especificada es true. Si la condición es false, otra sentencia puede ser ejecutada.
+- {{jsxref("Sentencias/switch", "switch")}}
+ - : Evalua una expresión, igualando el valor de la expresión a una clausula case y ejecuta las sentencias asociadas con dicho case.
+- {{jsxref("Sentencias/throw", "throw")}}
+ - : Lanza una excepción definida por el usuario.
+- {{jsxref("Sentencias/try...catch", "try...catch")}}
+ - : Marca un bloque de sentencias para ser probadas (try) y especifica una respuesta, en caso de que se lance una excepción.
+
+### Declaraciones
+
+- {{jsxref("Sentencias/var", "var")}}
+ - : Declara una variable, opcionalmente inicializándola a un valor.
+- {{jsxref("Sentencias/let", "let")}}
+ - : Declara una variable local de ambito de bloque, opcionalmente inicializándola a un valor.
+- {{jsxref("Sentencias/const", "const")}}
+ - : Declara una constante de solo lectura.
+
+### Funciones
+
+- {{jsxref("Sentencias/function", "function")}}
+ - : Declara una función con los parámetros especificados.
+- {{jsxref("Sentencias/function*", "function*")}}
+ - : Los generadores de funciones permiten escribir {{jsxref("Iteration_protocols", "iteradores")}} con mas facilidad.
+- {{experimental_inline}} {{jsxref("Statements/async_function", "async function")}}
+ - : Declara una función asíncrona con los parámetros especificados.
+- {{jsxref("Statements/return", "return")}}
+ - : Especifica el valor a ser retornado por una función.
+- {{jsxref("Statements/class", "class")}}
+ - : Declara una clase.
+
+### Iteraciones
+
+- {{jsxref("Sentencias/do...while", "do...while")}}
+ - : Crea un bucle que ejecuta una instrucción especificada hasta que la condición de prueba se evalúa como falsa. La condición se evalúa después de ejecutar la instrucción, lo que da como resultado que la instrucción especificada se ejecute al menos una vez.
+- {{jsxref("Sentencias/for", "for")}}
+ - : Creates a loop that consists of three optional expressions, enclosed in parentheses and separated by semicolons, followed by a statement executed in the loop.
+- {{deprecated_inline()}} {{non-standard_inline()}}{{jsxref("Sentencias/for_each...in", "for each...in")}}
+ - : Itera una variable especificada sobre todos los valores de las propiedades del objeto. Para cada propiedad distinta, se ejecuta una instrucción especificada.
+- {{jsxref("Sentencias/for...in", "for...in")}}
+ - : Itera sobre las propiedades enumerables de un objeto, en orden albitrario. Para cada propiedad distinta, las instrucciones pueden ser ejecutadas.
+- {{jsxref("Sentencias/for...of", "for...of")}}
+ - : Iterates over iterable objects (including {{jsxref("Array", "array")}}, array-like objects, [iterators and generators](/es/docs/JavaScript/Guide/Iterators_and_Generators "Iterators and generators")), invoking a custom iteration hook with statements to be executed for the value of each distinct property.
+- {{jsxref("Sentencias/while", "while")}}
+ - : Crea un bucle que ejecuta la instrucción especificada siempre que la condición de prueba se evalúe como verdadera. La condición se evalúa antes de ejecutar la instrucción.
+
+### Otros
+
+- {{jsxref("Sentencias/debugger", "debugger")}}
+ - : Invoca cualquier funcionalidad de depuración disponible. Si no hay funcionalidad de depuración disponible, esta isntrucción no tiene efecto.
+- {{jsxref("Sentencias/export", "export")}}
+ - : Usada para permitir a un script firmada proveer propiedades, funciones y objetos a otros scripts firmada o sin firmar. Esta antigua funcionalidad de Netscape ha sido removida y será redefinida por los modulos de ECMAScript 6
+- {{jsxref("Sentencias/import", "import")}}
+ - : Usada para permitir a un escript importar propiedades, funciones y objetos desde otro script firmado que ha exportado su información. Esta antigua funcionalidad de Netscape ha sido removida y será redefinida por los modulos de ECMAScript 6.
+- {{jsxref("Sentencias/label", "label")}}
+ - : Provee una instrucción con un identificador que puedes referir usando una instrucción `break` o `continue` .
+
+- {{deprecated_inline()}} {{jsxref("Sentencias/with", "with")}}
+ - : Extiende la cadena de alcance para una instrucción.
+
+## Especificaciones
+
+| Especificación | Status | Comentario |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------- | ---------------------------------------------- |
+| {{SpecName('ES1', '#sec-12', 'Statements')}} | {{Spec2('ES1')}} | Definición inicial |
+| {{SpecName('ES3', '#sec-12', 'Statements')}} | {{Spec2('ES3')}} | |
+| {{SpecName('ES5.1', '#sec-12', 'Statements')}} | {{Spec2('ES5.1')}} | |
+| {{SpecName('ES6', '#sec-ecmascript-language-statements-and-declarations', 'ECMAScript Language: Statements and Declarations')}} | {{Spec2('ES6')}} | Nuevo: function\*, let, for...of, yield, class |
+| {{SpecName('ESDraft', '#sec-ecmascript-language-statements-and-declarations', 'ECMAScript Language: Statements and Declarations')}} | {{Spec2('ESDraft')}} | |
+
+## Vea También
+
+- [Operadores](/es/docs/Web/JavaScript/Referencia/Operadores)
diff --git a/files/es/web/javascript/reference/statements/label/index.html b/files/es/web/javascript/reference/statements/label/index.html
deleted file mode 100644
index 4bdb5a6386af02..00000000000000
--- a/files/es/web/javascript/reference/statements/label/index.html
+++ /dev/null
@@ -1,36 +0,0 @@
----
-title: label
-slug: Web/JavaScript/Reference/Statements/label
-tags:
- - JavaScript
- - Statement
-translation_of: Web/JavaScript/Reference/Statements/label
-original_slug: Web/JavaScript/Referencia/Sentencias/label
----
-
- {{jsSidebar("Statements")}}
-Resumen
-Proporciona una sentencia con un identificador al que se puede referir al usar las sentencias {{jsxref("Sentencias/break", "break")}} o {{jsxref("Sentencias/continue", "continue")}}.
-Por ejemplo, puede usar una etiqueta para identificar un bucle, y entonces usar las sentencias break o continue para indicar si un programa debería interrumpir el bucle o continuar su ejecución.
-Sintaxis
-etiqueta :sentencia
-
-
- -
-
etiqueta
- -
- Cualquier identificador JavaScript que no sea una palabra reservada.
-
-
- -
-
sentencia
- -
- Sentencias.
break puede ser usado con cualquier sentencia etiquetada, y continue puede usarse con bucles etiquetados de sentencias.
-
-Ejemplos
-Para un ejemplo de una sentencia label usando break, vea break. Para un ejemplo de una sentencia label usando continue, vea continue.
-Vea También
-
- - {{jsxref("Sentencias/break", "break")}}
- - {{jsxref("Sentencias/continue", "continue")}}
-
diff --git a/files/es/web/javascript/reference/statements/label/index.md b/files/es/web/javascript/reference/statements/label/index.md
new file mode 100644
index 00000000000000..a7a3eb539de80e
--- /dev/null
+++ b/files/es/web/javascript/reference/statements/label/index.md
@@ -0,0 +1,35 @@
+---
+title: label
+slug: Web/JavaScript/Reference/Statements/label
+tags:
+ - JavaScript
+ - Statement
+translation_of: Web/JavaScript/Reference/Statements/label
+original_slug: Web/JavaScript/Referencia/Sentencias/label
+---
+{{jsSidebar("Statements")}}
+
+## Resumen
+
+Proporciona una sentencia con un identificador al que se puede referir al usar las sentencias {{jsxref("Sentencias/break", "break")}} o {{jsxref("Sentencias/continue", "continue")}}.
+
+Por ejemplo, puede usar una etiqueta para identificar un bucle, y entonces usar las sentencias `break` o `continue` para indicar si un programa debería interrumpir el bucle o continuar su ejecución.
+
+## Sintaxis
+
+ etiqueta :sentencia
+
+- `etiqueta`
+ - : Cualquier identificador JavaScript que no sea una palabra reservada.
+
+- `sentencia`
+ - : Sentencias. `break` puede ser usado con cualquier sentencia etiquetada, y `continue` puede usarse con bucles etiquetados de sentencias.
+
+## Ejemplos
+
+Para un ejemplo de una sentencia label usando `break`, vea `break`. Para un ejemplo de una sentencia label usando `continue`, vea `continue`.
+
+## Vea También
+
+- {{jsxref("Sentencias/break", "break")}}
+- {{jsxref("Sentencias/continue", "continue")}}
diff --git a/files/es/web/javascript/reference/statements/return/index.html b/files/es/web/javascript/reference/statements/return/index.html
deleted file mode 100644
index 3301106d0211fe..00000000000000
--- a/files/es/web/javascript/reference/statements/return/index.html
+++ /dev/null
@@ -1,74 +0,0 @@
----
-title: return
-slug: Web/JavaScript/Reference/Statements/return
-tags:
- - JavaScript
- - Statement
-translation_of: Web/JavaScript/Reference/Statements/return
-original_slug: Web/JavaScript/Referencia/Sentencias/return
----
-{{jsSidebar("Statements")}}
-
-Resumen
-
-La sentencia return finaliza la ejecución de la función y especifica un valor para ser devuelto a quien llama a la función.
-
-Sintaxis
-
-return [[ expresion ]];
-
-
- - expresion
- - La expresión a retornar. Si se omite,
undefined es retornado en su lugar.
-
-
-Description
-
-Cuando una instrucción de retorno se llama en una función, se detiene la ejecución de esta. Si se especifica un valor dado, este se devuelve a quien llama a la función. Si se omite la expresión, undefined se devuelve en su lugar. Todas las siguientes sentencias de retorno rompen la ejecución de la función:
-
-return;
-return true;
-return false;
-return x;
-return x + y / 3;
-
-
- La inserción automática Punto y coma
-
-La instrucción de retorno se ve afectada por la inserción automática de punto y coma (ASI). No se permite el terminador de línea entre la palabra clave de retorno y la expresión.
-
-return
-a + b;
-
-
-
-
-
- se transforma por ASI en:
-
-return;
-a + b;
-
-
- La consola le advertirá "código inalcanzable después de la declaración de retorno".
-
-
-
A partir de Gecko 40 {{geckoRelease(40)}}, una advertencia es mostrada en la consola si se encuentra código inalcanzable despues de una instrucción return.
-
Ejemplos
-
-Ejemplo: Usando return
-
-La siguiente función devuelve el cuadrado de su argumento, x, donde x es un número.
-
-function cuadrado(x) {
- return x * x;
-}
-
-
-Vea También
-
-
diff --git a/files/es/web/javascript/reference/statements/return/index.md b/files/es/web/javascript/reference/statements/return/index.md
new file mode 100644
index 00000000000000..e6f3b1719ec5fe
--- /dev/null
+++ b/files/es/web/javascript/reference/statements/return/index.md
@@ -0,0 +1,69 @@
+---
+title: return
+slug: Web/JavaScript/Reference/Statements/return
+tags:
+ - JavaScript
+ - Statement
+translation_of: Web/JavaScript/Reference/Statements/return
+original_slug: Web/JavaScript/Referencia/Sentencias/return
+---
+{{jsSidebar("Statements")}}
+
+## Resumen
+
+La sentencia `return` finaliza la ejecución de la función y especifica un valor para ser devuelto a quien llama a la función.
+
+## Sintaxis
+
+ return [[ expresion ]];
+
+- expresion
+ - : La expresión a retornar. Si se omite, `undefined` es retornado en su lugar.
+
+## Description
+
+Cuando una instrucción de retorno se llama en una función, se detiene la ejecución de esta. Si se especifica un valor dado, este se devuelve a quien llama a la función. Si se omite la expresión, `undefined` se devuelve en su lugar. Todas las siguientes sentencias de retorno rompen la ejecución de la función:
+
+```js
+return;
+return true;
+return false;
+return x;
+return x + y / 3;
+```
+
+##
La inserción automática Punto y coma
+
+La instrucción de retorno se ve afectada por la inserción automática de punto y coma (ASI). No se permite el terminador de línea entre la palabra clave de retorno y la expresión.
+
+```js
+return
+a + b;
+```
+
+se transforma por ASI en:
+
+```html
+return;
+a + b;
+```
+
+La consola le advertirá "código inalcanzable después de la declaración de retorno".
+
+> **Nota:** A partir de Gecko 40 {{geckoRelease(40)}}, una advertencia es mostrada en la consola si se encuentra código inalcanzable despues de una instrucción return.
+
+## Ejemplos
+
+### Ejemplo: Usando `return`
+
+La siguiente función devuelve el cuadrado de su argumento, `x`, donde `x` es un número.
+
+```js
+function cuadrado(x) {
+ return x * x;
+}
+```
+
+## Vea También
+
+- [Funciones](/es/docs/Web/JavaScript/Referencia/Funciones)
diff --git a/files/es/web/javascript/reference/statements/switch/index.html b/files/es/web/javascript/reference/statements/switch/index.html
deleted file mode 100644
index 47bf70e149ffcf..00000000000000
--- a/files/es/web/javascript/reference/statements/switch/index.html
+++ /dev/null
@@ -1,223 +0,0 @@
----
-title: switch
-slug: Web/JavaScript/Reference/Statements/switch
-translation_of: Web/JavaScript/Reference/Statements/switch
-original_slug: Web/JavaScript/Referencia/Sentencias/switch
----
-{{jsSidebar("Statements")}}
-
-La declaración switch evalúa una expresión, comparando el valor de esa expresión con una instancia case, y ejecuta declaraciones asociadas a ese case, así como las declaraciones en los case que siguen.
-
-Syntaxis
-
-switch (expresión) {
- case valor1:
- //Declaraciones ejecutadas cuando el resultado de expresión coincide con el valor1
- [break;]
- case valor2:
- //Declaraciones ejecutadas cuando el resultado de expresión coincide con el valor2
- [break;]
- ...
- case valorN:
- //Declaraciones ejecutadas cuando el resultado de expresión coincide con valorN
- [break;]
- default:
- //Declaraciones ejecutadas cuando ninguno de los valores coincide con el valor de la expresión
- [break;]
-}
-
-
- expresión- Es una expresión que es comparada con el valor de cada instancia
case.
- case valorN- Una instancia
case valorN es usada para ser comparada con la expresión. Si la expresión coincide con el valorN, las declaraciones dentro de la instancia case se ejecutan hasta que se encuentre el final de la declaración switch o hasta encontrar una interrupción break.
-
-
-
- - default
- - Una instancia
default, cuando es declarada, es ejecutada si el valor de la expresión no coincide con cualquiera de las otras instancias case valorN.
-
-
-Descripción
-
-Si ocurre una coincidencia, el programa ejecuta las declaraciones asociadas correspondientes. Si la expresión coincide con múltiples entradas, la primera será la seleccionada, incluso si las mayúsculas son tenidas en cuenta.
-
-El programa primero busca la primer instacia case cuya expresión se evalúa con el mismo valor de la expresión de entrada (usando comparación estricta, ===) y luego transfiere el control a esa cláusula, ejecutando las declaraciones asociadas. Si no se encuentra una cláusula de case coincidente, el programa busca la cláusula default opcional, y si se encuentra, transfiere el control a esa instancia, ejecutando las declaraciones asociadas. Si no se encuentra una instancia default el programa continúa la ejecución en la instrucción siguiente al final del switch. Por convención, la instancia default es la última cláusula, pero no tiene que ser así.
-
-La declaración break es opcional y está asociada con cada etiqueta de case y asegura que el programa salga del switch una vez que se ejecute la instrucción coincidente y continúe la ejecución en la instrucción siguiente. Si se omite el break el programa continúa la ejecución en la siguiente instrucción en la declaración de switch .
-
-Ejemplos
-
-Usando switch
-
-En el siguiente ejemplo, si expresión se resuelve a "Platanos", el algoritmo compara el valor con el case "Platanos" y ejecuta la declaración asociada. Cuando se encuentra un break, el programa sale del condicional switch y ejecuta la declaración que lo procede. Si se omite el break, el case "Cerezas" también es ejecutado.
-
-switch (expr) {
- case 'Naranjas':
- console.log('El kilogramo de naranjas cuesta $0.59.');
- break;
- case 'Manzanas':
- console.log('El kilogramo de manzanas cuesta $0.32.');
- break;
- case 'Platanos':
- console.log('El kilogramo de platanos cuesta $0.48.');
- break;
- case 'Cerezas':
- console.log('El kilogramo de cerezas cuesta $3.00.');
- break;
- case 'Mangos':
- case 'Papayas':
- console.log('El kilogramo de mangos y papayas cuesta $2.79.');
- break;
- default:
- console.log('Lo lamentamos, por el momento no disponemos de ' + expr + '.');
-}
-
-console.log("¿Hay algo más que te quisiera consultar?");
-
-¿Qué pasa si olvido un break?
-
-Si olvidas un break, el script se ejecutará desde donde se cumple la condición y ejecutará el siguiente case independientemente si esta condición se cumple o no. Ver el siguiente ejemplo:
-
-var foo = 0;
-switch (foo) {
- case -1:
- console.log('1 negativo');
- break;
- case 0: // foo es 0, por lo tanto se cumple la condición y se ejecutara el siguiente bloque
- console.log(0)
- // NOTA: el "break" olvidado debería estar aquí
- case 1: // No hay sentencia "break" en el 'case 0:', por lo tanto este caso también será ejecutado
- console.log(1);
- break; // Al encontrar un "break", no será ejecutado el 'case 2:'
- case 2:
- console.log(2);
- break;
- default:
- console.log('default');
-}
-
-
-¿Puedo usar un <default> entre condiciones?
-
-Sí, ¡es posible! JavaScript retornará a la instancia default en caso de no encontrar una coincidencia:
-
-var foo = 5;
-switch (foo) {
- case 2:
- console.log(2);
- break; // al encontrar este 'break' no se continuará con el siguiente 'default:'
- default:
- console.log('default')
- // fall-through
- case 1:
- console.log('1');
-}
-
-Al estar el case 1: a continuación de default, y al no haber un break de por medio, veremos que la declaración del case 1: será ejecutada, apareciendo el resultado 1 en el log de consola.
-
-Metodos para casos con múltiple criterio
-
-La fuente de esta técnica esta aquí:
-
-Switch statement multiple cases in JavaScript (Stack Overflow)
-
-Operación única con múltiples casos
-
-Este método toma ventaja del hecho de que, si no hay un break debajo de una declaración case, continuará la ejecución hasta el siguiente case, ignorando si en dicho caso se cumple o no el criterio indicado. Comprobar en la sección ¿Qué pasa si olvido un break?
-
-Este es un ejemplo de operación única con sentencia switch secuencial, donde cuatro valores diferentes se comportan exactamente de la misma manera:
-
-var Animal = 'Jirafa';
-switch (Animal) {
- case 'Vaca':
- case 'Jirafa':
- case 'Perro':
- case 'Cerdo':
- console.log('Este animal subirá al Arca de Noé.');
- break;
- case 'Dinosaurio':
- default:
- console.log('Este animal no lo hará.');
-}
-
-Operaciones encadenadas con múltiples casos
-
-Este es un ejemplo de una sentencia switch secuencial con múltiples operaciones, donde, dependiendo del valor entero dado, se pueden recibir diferentes resultados. Esto demuestra que el algoritmo correrá en el orden en que se coloquen las declaraciones case, y que no tiene que ser numéricamente secuencial. En JavaScript, también es posible combinar definiciones con valores "string" dentro de estas declaraciones case.
-
-var foo = 1;
-var output = 'Salida: ';
-switch (foo) {
- case 10:
- output += '¿Y ';
- case 1:
- output += 'Cuál ';
- output += 'Es ';
- case 2:
- output += 'Tu ';
- case 3:
- output += 'Nombre';
- case 4:
- output += '?';
- console.log(output);
- break;
- case 5:
- output += '!';
- console.log(output);
- break;
- default:
- console.log('Por favor, selecciona un valor del 1 al 6.');
-}
-
-La salida (output) de este ejemplo:
-
-
-
-
- | Value |
- Log text |
-
-
- | foo es NaN o no es 1, 2, 3, 4, 5 ni 10 |
- Por favor, selecciona un valor del 1 al 6. |
-
-
- | 10 |
- Salida: ¿Y Cuál Es Tu Nombre? |
-
-
- | 1 |
- Salida: Cuál Es Tu Nombre? |
-
-
- | 2 |
- Salida: Tu Nombre? |
-
-
- | 3 |
- Salida: Nombre? |
-
-
- | 4 |
- Salida: ? |
-
-
- | 5 |
- Salida: ! |
-
-
-
-
-Variables centradas en bloques sin un estamento de switch
-
-Con ECMAScript 2015 (ES6)
-
-Compatibilidad en Navegadores
-
-{{Compat("javascript.statements.switch")}}
-
-Ver también
-
-
diff --git a/files/es/web/javascript/reference/statements/switch/index.md b/files/es/web/javascript/reference/statements/switch/index.md
new file mode 100644
index 00000000000000..2f3115b3666c58
--- /dev/null
+++ b/files/es/web/javascript/reference/statements/switch/index.md
@@ -0,0 +1,195 @@
+---
+title: switch
+slug: Web/JavaScript/Reference/Statements/switch
+translation_of: Web/JavaScript/Reference/Statements/switch
+original_slug: Web/JavaScript/Referencia/Sentencias/switch
+---
+{{jsSidebar("Statements")}}
+
+La **declaración** **`switch`** evalúa una [expresión](/es/docs/Web/JavaScript/Guide/Expressions_and_Operators), comparando el valor de esa expresión con una instancia **`case`**, y ejecuta [declaraciones](/es/docs/Web/JavaScript/Referencia/Sentencias) asociadas a ese `case`, así como las declaraciones en los `case` que siguen.
+
+## Syntaxis
+
+ switch (expresión) {
+ case valor1:
+ //Declaraciones ejecutadas cuando el resultado de expresión coincide con el valor1
+ [break;]
+ case valor2:
+ //Declaraciones ejecutadas cuando el resultado de expresión coincide con el valor2
+ [break;]
+ ...
+ case valorN:
+ //Declaraciones ejecutadas cuando el resultado de expresión coincide con valorN
+ [break;]
+ default:
+ //Declaraciones ejecutadas cuando ninguno de los valores coincide con el valor de la expresión
+ [break;]
+ }
+
+- `expresión`
+ - : Es una expresión que es comparada con el valor de cada instancia `case`.
+- `case valorN`
+ - : Una instancia `case valorN` es usada para ser comparada con la `expresión`. Si la `expresión` coincide con el `valorN`, las declaraciones dentro de la instancia `case` se ejecutan hasta que se encuentre el final de la declaración `switch` o hasta encontrar una interrupción `break`.
+
+- `default`
+ - : Una instancia `default`, cuando es declarada, es ejecutada si el valor de la `expresión` no coincide con cualquiera de las otras instancias `case valorN`.
+
+## Descripción
+
+Si ocurre una coincidencia, el programa ejecuta las declaraciones asociadas correspondientes. Si la expresión coincide con múltiples entradas, la primera será la seleccionada, incluso si las mayúsculas son tenidas en cuenta.
+
+El programa primero busca la primer instacia `case` cuya expresión se evalúa con el mismo valor de la expresión de entrada (usando [comparación estricta](/es/docs/Web/JavaScript/Reference/Operators/Comparison_Operators), `===)` y luego transfiere el control a esa cláusula, ejecutando las declaraciones asociadas. Si no se encuentra una cláusula de `case` coincidente, el programa busca la cláusula `default` opcional, y si se encuentra, transfiere el control a esa instancia, ejecutando las declaraciones asociadas. Si no se encuentra una instancia `default` el programa continúa la ejecución en la instrucción siguiente al final del `switch`. Por convención, la instancia `default` es la última cláusula, pero no tiene que ser así.
+
+La declaración [`break`](/en-US/docs/Web/JavaScript/Reference/Statements/break "JavaScript/Reference/Statements/break") es opcional y está asociada con cada etiqueta de `case` y asegura que el programa salga del `switch` una vez que se ejecute la instrucción coincidente y continúe la ejecución en la instrucción siguiente. Si se omite el `break` el programa continúa la ejecución en la siguiente instrucción en la declaración de `switch` .
+
+## Ejemplos
+
+### Usando `switch`
+
+En el siguiente ejemplo, si `expresión` se resuelve a "Platanos", el algoritmo compara el valor con el `case` "Platanos" y ejecuta la declaración asociada. Cuando se encuentra un `break`, el programa sale del condicional `switch` y ejecuta la declaración que lo procede. Si se omite el `break`, el `case` "Cerezas" también es ejecutado.
+
+ switch (expr) {
+ case 'Naranjas':
+ console.log('El kilogramo de naranjas cuesta $0.59.');
+ break;
+ case 'Manzanas':
+ console.log('El kilogramo de manzanas cuesta $0.32.');
+ break;
+ case 'Platanos':
+ console.log('El kilogramo de platanos cuesta $0.48.');
+ break;
+ case 'Cerezas':
+ console.log('El kilogramo de cerezas cuesta $3.00.');
+ break;
+ case 'Mangos':
+ case 'Papayas':
+ console.log('El kilogramo de mangos y papayas cuesta $2.79.');
+ break;
+ default:
+ console.log('Lo lamentamos, por el momento no disponemos de ' + expr + '.');
+ }
+
+ console.log("¿Hay algo más que te quisiera consultar?");
+
+### ¿Qué pasa si olvido un break?
+
+Si olvidas un `break`, el script se ejecutará desde donde se cumple la condición y ejecutará el siguiente `case` independientemente si esta condición se cumple o no. Ver el siguiente ejemplo:
+
+```js
+var foo = 0;
+switch (foo) {
+ case -1:
+ console.log('1 negativo');
+ break;
+ case 0: // foo es 0, por lo tanto se cumple la condición y se ejecutara el siguiente bloque
+ console.log(0)
+ // NOTA: el "break" olvidado debería estar aquí
+ case 1: // No hay sentencia "break" en el 'case 0:', por lo tanto este caso también será ejecutado
+ console.log(1);
+ break; // Al encontrar un "break", no será ejecutado el 'case 2:'
+ case 2:
+ console.log(2);
+ break;
+ default:
+ console.log('default');
+}
+```
+
+### ¿Puedo usar un \ entre condiciones?
+
+Sí, ¡es posible! JavaScript retornará a la instancia `default` en caso de no encontrar una coincidencia:
+
+ var foo = 5;
+ switch (foo) {
+ case 2:
+ console.log(2);
+ break; // al encontrar este 'break' no se continuará con el siguiente 'default:'
+ default:
+ console.log('default')
+ // fall-through
+ case 1:
+ console.log('1');
+ }
+
+Al estar el `case 1:` a continuación de `default`, y al no haber un `break `de por medio, veremos que la declaración del `case 1:` será ejecutada, apareciendo el resultado `1` en el _log de consola._
+
+### Metodos para casos con múltiple criterio
+
+La fuente de esta técnica esta aquí:
+
+[Switch statement multiple cases in JavaScript (Stack Overflow)](http://stackoverflow.com/questions/13207927/switch-statement-multiple-cases-in-javascript)
+
+#### Operación única con múltiples casos
+
+Este método toma ventaja del hecho de que, si no hay un `break` debajo de una declaración `case`, continuará la ejecución hasta el siguiente `case`, ignorando si en dicho caso se cumple o no el criterio indicado. Comprobar en la sección _¿Qué pasa si olvido un `break`?_
+
+Este es un ejemplo de operación única con sentencia `switch` secuencial, donde cuatro valores diferentes se comportan exactamente de la misma manera:
+
+```js
+var Animal = 'Jirafa';
+switch (Animal) {
+ case 'Vaca':
+ case 'Jirafa':
+ case 'Perro':
+ case 'Cerdo':
+ console.log('Este animal subirá al Arca de Noé.');
+ break;
+ case 'Dinosaurio':
+ default:
+ console.log('Este animal no lo hará.');
+}
+```
+
+#### Operaciones encadenadas con múltiples casos
+
+Este es un ejemplo de una sentencia `switch` secuencial con múltiples operaciones, donde, dependiendo del valor entero dado, se pueden recibir diferentes resultados. Esto demuestra que el algoritmo correrá en el orden en que se coloquen las declaraciones `case`, y que no tiene que ser numéricamente secuencial. En JavaScript, también es posible combinar definiciones con valores \_`"string"` \_dentro de estas declaraciones `case`.
+
+```js
+var foo = 1;
+var output = 'Salida: ';
+switch (foo) {
+ case 10:
+ output += '¿Y ';
+ case 1:
+ output += 'Cuál ';
+ output += 'Es ';
+ case 2:
+ output += 'Tu ';
+ case 3:
+ output += 'Nombre';
+ case 4:
+ output += '?';
+ console.log(output);
+ break;
+ case 5:
+ output += '!';
+ console.log(output);
+ break;
+ default:
+ console.log('Por favor, selecciona un valor del 1 al 6.');
+}
+```
+
+La salida (output) de este ejemplo:
+
+| Value | Log text |
+| -------------------------------------- | ------------------------------------------ |
+| foo es NaN o no es 1, 2, 3, 4, 5 ni 10 | Por favor, selecciona un valor del 1 al 6. |
+| 10 | Salida: ¿Y Cuál Es Tu Nombre? |
+| 1 | Salida: Cuál Es Tu Nombre? |
+| 2 | Salida: Tu Nombre? |
+| 3 | Salida: Nombre? |
+| 4 | Salida: ? |
+| 5 | Salida: ! |
+
+### Variables centradas en bloques sin un estamento de switch
+
+Con ECMAScript 2015 (ES6)
+
+## Compatibilidad en Navegadores
+
+{{Compat("javascript.statements.switch")}}
+
+## Ver también
+
+- [`if...else`](/es/docs/Web/JavaScript/Reference/Statements/if...else)
diff --git a/files/es/web/javascript/reference/statements/throw/index.html b/files/es/web/javascript/reference/statements/throw/index.md
similarity index 50%
rename from files/es/web/javascript/reference/statements/throw/index.html
rename to files/es/web/javascript/reference/statements/throw/index.md
index abe7bcc7cfdc30..30317fd747cd98 100644
--- a/files/es/web/javascript/reference/statements/throw/index.html
+++ b/files/es/web/javascript/reference/statements/throw/index.md
@@ -7,36 +7,37 @@
translation_of: Web/JavaScript/Reference/Statements/throw
original_slug: Web/JavaScript/Referencia/Sentencias/throw
---
-{{jsSidebar("Statements")}}
+{{jsSidebar("Statements")}}
-Resumen
+## Resumen
-Lanza una excepcion definida por el usuario.
+Lanza una excepcion definida por el usuario.
-Sintaxis
+## Sintaxis
-throw expresion;
+ throw expresion;
-
- expresion- Expresión a lanzar.
-
+- `expresion`
+ - : Expresión a lanzar.
-Descripción
+## Descripción
-Utilice la sentencia throw para lanzar una excepción. Cuando lanza una excepción, expresion especifica el valor de la excepción. Cada uno de los siguientes ejemplos lanza una excepción:
+Utilice la sentencia `throw` para lanzar una excepción. Cuando lanza una excepción, `expresion` especifica el valor de la excepción. Cada uno de los siguientes ejemplos lanza una excepción:
-throw "Error2"; // genera una excepción con un valor cadena
+```js
+throw "Error2"; // genera una excepción con un valor cadena
throw 42; // genera una excepción con un valor 42
-throw true; // genera una excepción con un valor true
+throw true; // genera una excepción con un valor true
+```
-Ejemplos
+## Ejemplos
-Ejemplo: Lanzar un objeto
+### Ejemplo: Lanzar un objeto
-Puede especificar un objeto cuando lanza una excepción. Puede entonces referenciar las propiedades del objeto en el bloque catch. El siguiente ejemplo crea un objeto miExcepcionUsuario del tipo ExceptionUsuario y la utiliza usándola en una sentencia throw.
+Puede especificar un objeto cuando lanza una excepción. Puede entonces referenciar las propiedades del objeto en el bloque `catch`. El siguiente ejemplo crea un objeto `miExcepcionUsuario` del tipo `ExceptionUsuario` y la utiliza usándola en una sentencia `throw`.
-function ExceptionUsuario(mensaje) {
+```js
+function ExceptionUsuario(mensaje) {
this.mensaje = mensaje;
this.nombre = "ExceptionUsuario";
}
@@ -60,13 +61,14 @@ Ejemplo: Lan
nombreMes = "desconocido";
registrarMisErrores(excepcion.mensaje, excepcion.nombre); // pasa el objeto exception al manejador de errores
}
-
+```
-Ejemplo: Otro ejemplo sobre lanzar un objeto
+### Ejemplo: Otro ejemplo sobre lanzar un objeto
-El siguiente ejemplo comprueba una cadena de entrada para un código postal de EE.UU. Si el código postal utiliza un formato no válido, la sentencia throw lanza una excepción creando un objeto de tipo ExcepcionFormatoCodigoPostal.
+El siguiente ejemplo comprueba una cadena de entrada para un código postal de EE.UU. Si el código postal utiliza un formato no válido, la sentencia throw lanza una excepción creando un objeto de tipo `ExcepcionFormatoCodigoPostal`.
-/*
+```js
+/*
* Creates a ZipCode object.
*
* Accepted formats for a zip code are:
@@ -129,26 +131,23 @@
+```
-Ejemplo: Relanzar una excepción
+### Ejemplo: Relanzar una excepción
-
Puede usar throw para volver a lanzar una excepción después de cogerla. El siguiente ejemplo coge una excepción con un valor numérico y la vuelve a lanzar si el valor es superior a 50. La excepción relanzada propaga hacia arriba la función adjunta o a un nivel superior para que el usuario pueda verla.
+Puede usar `throw` para volver a lanzar una excepción después de cogerla. El siguiente ejemplo coge una excepción con un valor numérico y la vuelve a lanzar si el valor es superior a 50. La excepción relanzada propaga hacia arriba la función adjunta o a un nivel superior para que el usuario pueda verla.
-try {
- throw n; // lanza una excepción con un valor numérico
-} catch (excepcion) {
- if (excepcion <= 50) {
- // sentencias para manejar la excepción 1-50
- } else {
- // no se puede manejar esta excepción, así que se vuelve a lanzar
- throw excepcion;
- }
-}
-
+ try {
+ throw n; // lanza una excepción con un valor numérico
+ } catch (excepcion) {
+ if (excepcion <= 50) {
+ // sentencias para manejar la excepción 1-50
+ } else {
+ // no se puede manejar esta excepción, así que se vuelve a lanzar
+ throw excepcion;
+ }
+ }
-Vea También
+## Vea También
-
- - {{jsxref("Sentencias/try...catch", "try...catch")}}
-
+- {{jsxref("Sentencias/try...catch", "try...catch")}}
diff --git a/files/es/web/javascript/reference/statements/try...catch/index.html b/files/es/web/javascript/reference/statements/try...catch/index.html
deleted file mode 100644
index 4beed9c786822f..00000000000000
--- a/files/es/web/javascript/reference/statements/try...catch/index.html
+++ /dev/null
@@ -1,255 +0,0 @@
----
-title: try...catch
-slug: Web/JavaScript/Reference/Statements/try...catch
-tags:
- - Error
- - Excepción
- - JavaScript
- - Statement
-translation_of: Web/JavaScript/Reference/Statements/try...catch
-original_slug: Web/JavaScript/Referencia/Sentencias/try...catch
----
-{{jsSidebar("Statements")}}
-
-La declaración try...catch señala un bloque de instrucciones a intentar (try), y especifica una respuesta si se produce una excepción (catch).
-
-{{EmbedInteractiveExample("pages/js/statement-trycatch.html")}}
-
-Sintaxis
-
-try {
- try_statements
-}
-[catch (exception_var_1 if condition_1) { // non-standard
- catch_statements_1
-}]
-...
-[catch (exception_var_2) {
- catch_statements_2
-}]
-[finally {
- finally_statements
-}]
-
-
-
- try_statements- Las sentencias que serán ejecutadas.
-
-
-
- catch_statements_1, catch_statements_2- Sentencias que se ejecutan si una excepción es lanzada en el bloque
try.
-
-
-
- exception_var_1, exception_var_2- Identificador que contiene un objeto de excepcion asociado a la cláusula
catch.
-
-
-
- condition_1- Una expresión condicional.
-
-
-
- finally_statements- Sentencias que se ejecutan después de que se completa la declaración
try . Estas sentencias se ejecutan independientemente de si una excepcion fue lanzada o capturada.
-
-
-Descripción
-
-La sentencia try consiste en un bloque try que contiene una o más sentencias. Las llaves {} se deben utilizar siempre, incluso para una bloques de una sola sentencia. Al menos un bloque catch o un bloque finally debe estar presente. Esto nos da tres formas posibles para la sentencia try:
-
-
- try...catchtry...finallytry...catch...finally
-
-Un bloque catch contiene sentencias que especifican que hacer si una excepción es lanzada en el bloque try. Si cualquier sentencia dentro del bloque try (o en una funcion llamada desde dentro del bloque try) lanza una excepción, el control cambia inmediatamente al bloque catch . Si no se lanza ninguna excepcion en el bloque try, el bloque catch se omite.
-
-La bloque finally se ejecuta despues del bloque try y el/los bloque(s) catch hayan finalizado su ejecución. Éste bloque siempre se ejecuta, independientemente de si una excepción fue lanzada o capturada.
-
-Puede anidar una o más sentencias try. Si una sentencia try interna no tiene una bloque catch, se ejecuta el bloque catch de la sentencia try que la encierra.
-
-Usted también puede usar la declaración try para manejar excepciones de JavaScript. Consulte la Guía de JavaScript para obtener mayor información sobre excepciones de JavaScript.
-
-
-Bloque catch incondicional
-
-Cuando solo se utiliza un bloque catch, el bloque catch es ejecutado cuando cualquier excepción es lanzada. Por ejemplo, cuando la excepción ocurre en el siguiente código, el control se transfiere a la cláusula catch.
-
-try {
- throw "myException"; // genera una excepción
-}
-catch (e) {
- // sentencias para manejar cualquier excepción
- logMyErrors(e); // pasa el objeto de la excepción al manejador de errores
-}
-
-
-El bloque catch especifíca un identificador ( e en el ejemplo anterior) que contiene el valor de la excepción. Este valor está solo disponible en el {{Glossary("Scope", "scope")}} de el bloque catch
-
-Bloques catch condicionales
-
-Tambien se pueden crear "bloques catch condicionales", combinando bloques try...catch con estructuras if...else if...else como estas:
-
-try {
- myroutine();
-} catch (e) {
- if (e instanceof TypeError) {
-
- } else if (e instanceof RangeError) {
-
- } else if (e instanceof EvalError) {
-
- } else {
-
- logMyErrors(e); pasa el objeto de la excepción al manejador de errores
-}
-
-El identificador de excepciones
-
-Cuando una excepción es lanzada en el bloque try, exception_var (por ejemplo, la e en catch (e)) guarda el valor de la excepción. Se puede usar éste identificador para obtener información acerca de la excepción que fue lanzada. Este valor está solo disponible en el {{Glossary("Scope", "scope")}} de el bloque catch.
-
-function isValidJSON(text) {
- try {
- JSON.parse(text);
- return true;
- } catch {
- return false;
- }
-}
-
-La cláusula finally
-
-La cláusula finally contiene sentencias a ejecutarse después de que las cláusulas try y catch se ejecuten, pero antes de las sentencias que le siguen al bloque try..catch..finally. Note que la cláusula finally se ejecuta sin importar si una excepción es o no lanzada. Si una excepción es lanzada, las instrucciones en la cláusula finally se ejecutan incluso si ninguna cláusula catch maneja la excepción.
-
-Usted puede usar la cláusula finally para hacer que su script falle plácidamente cuando una excepción ocurra; por ejemplo, para hacer una limpieza general, usted puede necesitar liberar un recurso que su script haya retenido.
-
-Puede parecer extraño tener una cláusula relacionada a una excepción que se ejecuta sin importar si hay una excepción o no, pero esta concepción en realidad sirve a un propósito. El punto importante no es que la cláusula finally siempre se ejecuta, si no más bien que el codigo ordinario que le sigue a try..catch no.
-
-Por ejemplo, si otra excepción ocurre dentro de un bloque catch de una declaración try, cualquier codigo restante en el mismo bloque exterior try que encierra ese try..catch (o en el flujo principal, si no es un bloque try exterior) , no será ejecutado, dado que el control es inmediatamente transferido al bloque catch del try exterior (o el generador de error interno, si no es en un bloque try).
-
-Por lo tanto, cualquier rutina de limpieza hecha en esa sección encerrada (o la principal) antes de que exista, será saltada. Sin embargo, si la declaración try tiene un bloque finally, entonces el código de ese bloque finally será ejecutado primero para permitir tal limpieza, y ENTONCES el bloque catch de la otra declaración try (o el generador de error) tomará el control para manejar la segunda excepción.
-
-Ahora, si esa rutina de limpieza debiera ser hecha ya sea que el código del try..catch tenga éxito o no, entonces si el bloque finally se ejecutase solo después de una excepción, el mismo código de limpieza tendría que estar presente dentro y fuera del bloque finally, y por lo tanto no hay razón para no tener el bloque finally solo, y dejarlo ejecutarse sin importar si hay excepciones o no.
-
-El siguiente ejemplo abre un archivo y despues ejecuta sentencias que usan el archivo (JavaScript del lado del servidor permite acceder a archivos). Si una excepción es lanzada mientras el archivo está abierto, la cláusula finally cierra el archivo antes de que el script falle. El código en finally también se ejecuta después de un retorno explícito de los bloques try o catch.
-
-openMyFile()
-try {
- // retiene un recurso
- writeMyFile(theData);
-}
-finally {
- closeMyFile(); // siempre cierra el recurso
-}
-
-
-Ejemplos
-
-Bloques try anidados
-
-Primero, veamos que pasa con esto:
-
-try {
- try {
- throw new Error('oops');
- }
- finally {
- console.log('finally');
- }
-}
-catch (ex) {
- console.error('outer', ex.message);
-}
-
-
-
-
-
-Ahora, si nosotros ya capturamos la excepción en una declaración try interna agregando un bloque catch.
-
-try {
- try {
- throw new Error('oops');
- }
- catch (ex) {
- console.error('inner', ex.message);
- }
- finally {
- console.log('finally');
- }
-}
-catch (ex) {
- console.error('outer', ex.message);
-}
-
-
-
-
-
-Y ahora vamos a relanzar el error.
-
-try {
- try {
- throw new Error('oops');
- }
- catch (ex) {
- console.error('inner', ex.message);
- throw ex;
- }
- finally {
- console.log('finally');
- }
-}
-catch (ex) {
- console.error('outer', ex.message);
-}
-
-
-
-
-
-
-Cualquier excepción dada será capturada solo una vez por el bloque catch más cercano a menos que sea relanzado. Por supuesto cualquier nueva excepción que se origine en el bloque 'interno' (porque el código en el bloque catch puede hacer algo que lanze un error), será capturado por el bloque 'externo'.
-
-Retornando de un bloque finally
-
-Si el bloque finally retorna un valor, este valor se convierte en el valor de retorno de toda la producción try-catch-finally, a pesar de cualquier sentencia return en los bloques try y catch. Esto incluye excepciones lanzadas dentro del bloque catch.
-
-(function() {
- try {
- try {
- throw new Error('oops');
- }
- catch (ex) {
- console.error('inner', ex.message);
- throw ex;
- }
- finally {
- console.log('finally');
- return;
- }
- }
- catch (ex) {
- console.error('outer', ex.message);
- }
-})();
-
-
-
-
-
-El "oops" externo no es lanzado debido al retorno en el bloque finally. Lo mismo aplicaría para cualquier valor retornado del bloque catch.
-
-Vea los ejemplos para {{jsxref("Sentencias/throw", "throw")}}.
-
-Vea también
-
-
- - {{jsxref("Error")}}
- - {{jsxref("Sentencias/throw", "throw")}}
-
diff --git a/files/es/web/javascript/reference/statements/try...catch/index.md b/files/es/web/javascript/reference/statements/try...catch/index.md
new file mode 100644
index 00000000000000..1f9110b585e134
--- /dev/null
+++ b/files/es/web/javascript/reference/statements/try...catch/index.md
@@ -0,0 +1,253 @@
+---
+title: try...catch
+slug: Web/JavaScript/Reference/Statements/try...catch
+tags:
+ - Error
+ - Excepción
+ - JavaScript
+ - Statement
+translation_of: Web/JavaScript/Reference/Statements/try...catch
+original_slug: Web/JavaScript/Referencia/Sentencias/try...catch
+---
+{{jsSidebar("Statements")}}
+
+La declaración **`try...catch`** señala un bloque de instrucciones a intentar (**`try`**), y especifica una respuesta si se produce una excepción (**`catch`**).
+
+{{EmbedInteractiveExample("pages/js/statement-trycatch.html")}}
+
+## Sintaxis
+
+ try {
+ try_statements
+ }
+ [catch (exception_var_1 if condition_1) { // non-standard
+ catch_statements_1
+ }]
+ ...
+ [catch (exception_var_2) {
+ catch_statements_2
+ }]
+ [finally {
+ finally_statements
+ }]
+
+- `try_statements`
+ - : Las sentencias que serán ejecutadas.
+
+- `catch_statements_1`, `catch_statements_2`
+ - : Sentencias que se ejecutan si una excepción es lanzada en el bloque `try`.
+
+- `exception_var_1`, `exception_var_2`
+ - : Identificador que contiene un objeto de excepcion asociado a la cláusula `catch`.
+
+- `condition_1`
+ - : Una expresión condicional.
+
+- `finally_statements`
+ - : Sentencias que se ejecutan después de que se completa la declaración `try` . Estas sentencias se ejecutan independientemente de si una excepcion fue lanzada o capturada.
+
+## Descripción
+
+La sentencia `try` consiste en un bloque `try` que contiene una o más sentencias. Las llaves `{}` se deben utilizar siempre`,` incluso para una bloques de una sola sentencia. Al menos un bloque `catch` o un bloque `finally` debe estar presente. Esto nos da tres formas posibles para la sentencia `try`:
+
+1. `try...catch`
+2. `try...finally`
+3. `try...catch...finally`
+
+Un bloque `catch` contiene sentencias que especifican que hacer si una excepción es lanzada en el bloque `try`. Si cualquier sentencia dentro del bloque `try` (o en una funcion llamada desde dentro del bloque `try`) lanza una excepción, el control cambia inmediatamente al bloque `catch` . Si no se lanza ninguna excepcion en el bloque `try`, el bloque `catch` se omite.
+
+La bloque `finally` se ejecuta despues del bloque `try` y el/los bloque(s) `catch` hayan finalizado su ejecución. Éste bloque siempre se ejecuta, independientemente de si una excepción fue lanzada o capturada.
+
+Puede anidar una o más sentencias `try`. Si una sentencia `try` interna no tiene una bloque `catch`, se ejecuta el bloque `catch` de la sentencia `try` que la encierra.
+
+Usted también puede usar la declaración `try` para manejar excepciones de JavaScript. Consulte la [Guía de JavaScript](/es/docs/Web/JavaScript/Guide) para obtener mayor información sobre excepciones de JavaScript.
+
+### Bloque catch incondicional
+
+Cuando solo se utiliza un bloque `catch`, el bloque `catch` es ejecutado cuando cualquier excepción es lanzada. Por ejemplo, cuando la excepción ocurre en el siguiente código, el control se transfiere a la cláusula `catch`.
+
+```js
+try {
+ throw "myException"; // genera una excepción
+}
+catch (e) {
+ // sentencias para manejar cualquier excepción
+ logMyErrors(e); // pasa el objeto de la excepción al manejador de errores
+}
+```
+
+El bloque `catch` especifíca un identificador ( `e` en el ejemplo anterior) que contiene el valor de la excepción. Este valor está solo disponible en el {{Glossary("Scope", "scope")}} de el bloque` catch`
+
+### Bloques catch condicionales
+
+Tambien se pueden crear "bloques `catch` condicionales", combinando bloques `try...catch` con estructuras `if...else if...else` como estas:
+
+```js
+try {
+ myroutine(); // puede lanzar tres tipos de excepciones
+} catch (e) {
+ if (e instanceof TypeError) {
+ // sentencias para manejar excepciones TypeError
+ } else if (e instanceof RangeError) {
+ // sentencias para manejar excepciones RangeError
+ } else if (e instanceof EvalError) {
+ // sentencias para manejar excepciones EvalError
+ } else {
+ // sentencias para manejar cualquier excepción no especificada
+ logMyErrors(e); // pasa el objeto de la excepción al manejador de errores
+}
+```
+
+### El identificador de excepciones
+
+Cuando una excepción es lanzada en el bloque `try`, `exception_var` (por ejemplo, la `e` en `catch (e)`) guarda el valor de la excepción. Se puede usar éste identificador para obtener información acerca de la excepción que fue lanzada. Este valor está solo disponible en el {{Glossary("Scope", "scope")}} de el bloque` catch.`
+
+```js
+function isValidJSON(text) {
+ try {
+ JSON.parse(text);
+ return true;
+ } catch {
+ return false;
+ }
+}
+```
+
+### La cláusula `finally`
+
+La cláusula `finally` contiene sentencias a ejecutarse después de que las cláusulas `try` y `catch` se ejecuten, pero antes de las sentencias que le siguen al bloque `try..catch..finally`. Note que la cláusula `finally` se ejecuta sin importar si una excepción es o no lanzada. Si una excepción es lanzada, las instrucciones en la cláusula `finally` se ejecutan incluso si ninguna cláusula `catch` maneja la excepción.
+
+Usted puede usar la cláusula finally para hacer que su script falle plácidamente cuando una excepción ocurra; por ejemplo, para hacer una limpieza general, usted puede necesitar liberar un recurso que su script haya retenido.
+
+Puede parecer extraño tener una cláusula relacionada a una excepción que se ejecuta sin importar si hay una excepción o no, pero esta concepción en realidad sirve a un propósito. El punto importante no es que la cláusula `finally` siempre se ejecuta, si no más bien que el codigo ordinario que le sigue a `try..catch` no.
+
+Por ejemplo, si otra excepción ocurre dentro de un bloque `catch` de una declaración `try`, cualquier codigo restante en el mismo bloque exterior `try` que encierra ese `try..catch` (o en el flujo principal, si no es un bloque `try` exterior) , no será ejecutado, dado que el control es inmediatamente transferido al bloque `catch` del `try` exterior (o el generador de error interno, si no es en un bloque `try`).
+
+Por lo tanto, cualquier rutina de limpieza hecha en esa sección encerrada (o la principal) antes de que exista, será saltada. Sin embargo, si la declaración `try` tiene un bloque `finally`, entonces el código de ese bloque `finally` será ejecutado primero para permitir tal limpieza, y ENTONCES el bloque `catch` de la otra declaración `try` (o el generador de error) tomará el control para manejar la segunda excepción.
+
+Ahora, si esa rutina de limpieza debiera ser hecha ya sea que el código del `try..catch` tenga éxito o no, entonces si el bloque `finally` se ejecutase solo después de una excepción, el mismo código de limpieza tendría que estar presente dentro y fuera del bloque `finally`, y por lo tanto no hay razón para no tener el bloque `finally` solo, y dejarlo ejecutarse sin importar si hay excepciones o no.
+
+El siguiente ejemplo abre un archivo y despues ejecuta sentencias que usan el archivo (JavaScript del lado del servidor permite acceder a archivos). Si una excepción es lanzada mientras el archivo está abierto, la cláusula `finally` cierra el archivo antes de que el script falle. El código en `finally` también se ejecuta después de un retorno explícito de los bloques `try` o `catch`.
+
+```js
+openMyFile()
+try {
+ // retiene un recurso
+ writeMyFile(theData);
+}
+finally {
+ closeMyFile(); // siempre cierra el recurso
+}
+```
+
+## Ejemplos
+
+### Bloques try anidados
+
+Primero, veamos que pasa con esto:
+
+```js
+try {
+ try {
+ throw new Error('oops');
+ }
+ finally {
+ console.log('finally');
+ }
+}
+catch (ex) {
+ console.error('outer', ex.message);
+}
+
+// Output:
+// "finally"
+// "outer" "oops"
+```
+
+Ahora, si nosotros ya capturamos la excepción en una declaración try interna agregando un bloque catch.
+
+```js
+try {
+ try {
+ throw new Error('oops');
+ }
+ catch (ex) {
+ console.error('inner', ex.message);
+ }
+ finally {
+ console.log('finally');
+ }
+}
+catch (ex) {
+ console.error('outer', ex.message);
+}
+
+// Output:
+// "inner" "oops"
+// "finally"
+```
+
+Y ahora vamos a relanzar el error.
+
+```js
+try {
+ try {
+ throw new Error('oops');
+ }
+ catch (ex) {
+ console.error('inner', ex.message);
+ throw ex;
+ }
+ finally {
+ console.log('finally');
+ }
+}
+catch (ex) {
+ console.error('outer', ex.message);
+}
+
+// Output:
+// "inner" "oops"
+// "finally"
+// "outer" "oops"
+```
+
+Cualquier excepción dada será capturada solo una vez por el bloque catch más cercano a menos que sea relanzado. Por supuesto cualquier nueva excepción que se origine en el bloque 'interno' (porque el código en el bloque catch puede hacer algo que lanze un error), será capturado por el bloque 'externo'.
+
+### Retornando de un bloque finally
+
+Si el bloque `finally` retorna un valor, este valor se convierte en el valor de retorno de toda la producción `try-catch-finally`, a pesar de cualquier sentencia `return` en los bloques `try` y `catch`. Esto incluye excepciones lanzadas dentro del bloque catch.
+
+```js
+(function() {
+ try {
+ try {
+ throw new Error('oops');
+ }
+ catch (ex) {
+ console.error('inner', ex.message);
+ throw ex;
+ }
+ finally {
+ console.log('finally');
+ return;
+ }
+ }
+ catch (ex) {
+ console.error('outer', ex.message);
+ }
+})();
+
+// Output:
+// "inner" "oops"
+// "finally"
+```
+
+El "oops" externo no es lanzado debido al retorno en el bloque finally. Lo mismo aplicaría para cualquier valor retornado del bloque catch.
+
+Vea los ejemplos para {{jsxref("Sentencias/throw", "throw")}}.
+
+## Vea también
+
+- {{jsxref("Error")}}
+- {{jsxref("Sentencias/throw", "throw")}}
diff --git a/files/es/web/javascript/reference/statements/var/index.html b/files/es/web/javascript/reference/statements/var/index.html
deleted file mode 100644
index 02f59b44edec29..00000000000000
--- a/files/es/web/javascript/reference/statements/var/index.html
+++ /dev/null
@@ -1,164 +0,0 @@
----
-title: var
-slug: Web/JavaScript/Reference/Statements/var
-tags:
- - JavaScript
- - Statement
-translation_of: Web/JavaScript/Reference/Statements/var
-original_slug: Web/JavaScript/Referencia/Sentencias/var
----
-{{jsSidebar("Statements")}}
-
-Resumen
-
-La sentencia var declara una variable, opcionalmente inicializándola con un valor.
-
-Sintaxis
-
-var nombreDeVariable1 [= valor1] [, nombreDeVariable2 [= valor2] ... [, nombreDeVariableN [=valorN]]];
-
-
- nombreDeVariableN- Representa el nombre que el programador da a la variable. Puede ser cualquier identificador legal.
-
-
-
- valorN- Valor inicial de la variable. Puede ser cualquier expresión legal. El valor predeterminado es undefined (en español, indefinida).
-
-
-Descripción
-
-Las declaraciones de variables, donde sea que ocurran, son procesadas antes de que cualquier otro código sea ejecutado. El ámbito de una variable declarada con la palabra reservada var es su contexto de ejecución en curso, que puede ser la función que la contiene o, para las variables declaradas afuera de cualquier función, un ámbito global. Si re-declaras una variable Javascript, esta no perderá su valor.
-
-Asignar un valor a una variable no declarada implica crearla como variable global (se convierte en una propiedad del objeto global) cuando la asignación es ejecutada. Las diferencias entre una variable declarada y otra sin declarar son:
-
-1. Las variables declaradas se limitan al contexto de ejecución en el cual son declaradas. Las variables no declaradas siempre son globales.
-
-function x() {
- y = 1;
- var z = 2;
-}
-
-x();
-
-console.log(y);
-console.log(z);
-
-2. Las variables declaradas son creadas antes de ejecutar cualquier otro código. Las variables sin declarar no existen hasta que el código que las asigna es ejecutado.
-
-console.log(a);
-console.log('trabajando...');
-
-var a;
-console.log(a);
-console.log('trabajando...'); trabajando
-
-3. Las variables declaradas son una propiedad no-configurable de su contexto de ejecución (de función o global). Las variables sin declarar son configurables (p. ej. pueden borrarse).
-
-var a = 1;
-b = 2;
-
-delete this.a;
-delete this.b;
-
-console.log(a, b);
-
-
-Debido a esas tres diferencias, fallar al declarar variables muy probablemente llevará a resultados inesperados. Por tanto se recomienda siempre declarar las variables, sin importar si están en una función o un ámbito global. Y en el modo estricto (strict mode) de ECMAScript 5, asignar valor a una variable sin declarar lanzará un error.
-
-Elevación de variables
-
-Como la declaración de variables (y todas las declaraciones en general) se procesa antes de ejecutar cualquier código, declarar una variable en cualquier parte del código es equivalente a declararla al inicio del mismo. Esto también significa que una variable puede parecer usarse antes de ser declarada. Este comportamiento es llamado hoisting (del inglés "elevación"), ya que la declaración de una variable parecer haber sido movida a la cima de la función o código global.
-
-bla = 2;
-var bla;
-
-
-
-
-var bla;
-bla = 2;
-
-Por esa razón, se recomienda siempre declarar variables al inicio de su ámbito (la cima del código global y la cima del código de función) para que sea claro cuáles variables pertenecen al ámbito de función (local) y cuáles son resueltas en la cadena de ámbito.
-
-Es importante señalar que la elevación afectará la declaración de variables, pero no su inicialización. El valor será asignado precisamente cuando la sentencia de asignación sea alcanzada:
-
-function haz_algo() {
- console.log(bar);
- var bar = 111;
- console.log(bar);
-}
-
-
-function haz_algo() {
- var bar;
- console.log(bar);
- bar = 111;
- console.log(bar);
-}
-
-
-
-Ejemplos
-
-Declarando e inicializando dos variables
-
-var a = 0, b = 0;
-
-Asignando dos variables con un solo valor de cadena
-
-var a = 'A';
-var b = a;
-
-
-
-var a, b = a = 'A';
-
-Sé consciente del orden:
-
-var x = y, y = 'A';
-console.log(x + y);
-
-Aquí, 'x' & 'y' son declaradas antes de ejecutarse cualquier código, y la asignación ocurre después. Al momento de evaluar "x = y", 'y' existe así que ningún error "ReferenceError" es lanzado y su valor es 'undefined', de modo que 'x' también tiene asignada el valor 'undefined'. Después, a 'y' se le asigna el valor 'A'. Consecuentemente, luego de la primera línea, 'x' es exactamente igual a 'undefined' & 'y' es igual a 'A', de ahí el resultado.
-
-Initialización de muchas variables
-
-var x = 0;
-
-function f() {
- var x = y = 1;
-}
-f();
-
-console.log(x, y);
-
-
-
-
-Globales implícitas y ámbito externo a una función
-
-Las variables que parecen ser globales implícitas pueden ser referencias a variables en un ámbito externo a la función:
-
-var x = 0; .
-
-console.log(typeof z); .
-
-function a() {
- var y = 2; .
-
- console.log(x, y); ".
-
- function b() {
- x = 3;
- y = 4;
- z = 5;
- }
-
- b();
- console.log(x, y, z); ".
-}
-
-a(); ()'.
-console.log(x, z); ", porque 'z' ya es una global.
-console.log(typeof y);
diff --git a/files/es/web/javascript/reference/statements/var/index.md b/files/es/web/javascript/reference/statements/var/index.md
new file mode 100644
index 00000000000000..b05f4452e88e53
--- /dev/null
+++ b/files/es/web/javascript/reference/statements/var/index.md
@@ -0,0 +1,180 @@
+---
+title: var
+slug: Web/JavaScript/Reference/Statements/var
+tags:
+ - JavaScript
+ - Statement
+translation_of: Web/JavaScript/Reference/Statements/var
+original_slug: Web/JavaScript/Referencia/Sentencias/var
+---
+{{jsSidebar("Statements")}}
+
+## Resumen
+
+La sentencia **`var`** declara una variable, opcionalmente inicializándola con un valor.
+
+## Sintaxis
+
+ var nombreDeVariable1 [= valor1] [, nombreDeVariable2 [= valor2] ... [, nombreDeVariableN [=valorN]]];
+
+- `nombreDeVariableN`
+ - : Representa el nombre que el programador da a la variable. Puede ser cualquier identificador legal.
+
+- `valorN`
+ - : Valor inicial de la variable. Puede ser cualquier expresión legal. El valor predeterminado es _undefined_ (en español, _indefinida_).
+
+## Descripción
+
+Las declaraciones de variables, donde sea que ocurran, son procesadas antes de que cualquier otro código sea ejecutado. El ámbito de una variable declarada con la palabra reservada **`var`** es su _contexto de ejecución_ en curso*,* que puede ser la función que la contiene o, para las variables declaradas afuera de cualquier función, un ámbito global. Si re-declaras una variable Javascript, esta no perderá su valor.
+
+Asignar un valor a una variable no declarada implica crearla como variable global (se convierte en una propiedad del objeto global) cuando la asignación es ejecutada. Las diferencias entre una variable declarada y otra sin declarar son:
+
+1\. Las variables declaradas se limitan al contexto de ejecución en el cual son declaradas. Las variables no declaradas siempre son globales.
+
+```js
+function x() {
+ y = 1; // Lanza un error de tipo "ReferenceError" en modo estricto ('use strict')
+ var z = 2;
+}
+
+x();
+
+console.log(y); // Imprime "1"
+console.log(z); // Lanza un error de tipo "ReferenceError": z no está definida afuera de x
+```
+
+2\. Las variables declaradas son creadas antes de ejecutar cualquier otro código. Las variables sin declarar no existen hasta que el código que las asigna es ejecutado.
+
+```js
+console.log(a); // Lanza un error de tipo "ReferenceError".
+console.log('trabajando...'); // Nunca se ejecuta.
+```
+
+```js
+var a;
+console.log(a); // Imprime "undefined" o "" dependiendo del navegador.
+console.log('trabajando...'); // Imprime "trabajando...".
+```
+
+3\. Las variables declaradas son una propiedad no-configurable de su contexto de ejecución (de función o global). Las variables sin declarar son configurables (p. ej. pueden borrarse).
+
+```js
+var a = 1;
+b = 2;
+
+delete this.a; // Lanza un error de tipo "ReferenceError" en modo estricto ('use strict'), de lo contrario falla silenciosamente.
+delete this.b;
+
+console.log(a, b); // Lanza un error de tipo "ReferenceError".
+// La propiedad 'b' se eliminó y ya no existe.
+```
+
+Debido a esas tres diferencias, fallar al declarar variables muy probablemente llevará a resultados inesperados. Por tanto **se recomienda siempre declarar las variables, sin importar si están en una función o un ámbito global**. Y en el modo estricto ([strict mode](/es/docs/Web/JavaScript/Reference/Functions_and_function_scope/Strict_mode)) de ECMAScript 5, asignar valor a una variable sin declarar lanzará un error.
+
+### Elevación de variables
+
+Como la declaración de variables (y todas las declaraciones en general) se procesa antes de ejecutar cualquier código, declarar una variable en cualquier parte del código es equivalente a declararla al inicio del mismo. Esto también significa que una variable puede parecer usarse antes de ser declarada. Este comportamiento es llamado _hoisting_ (del inglés "elevación"), ya que la declaración de una variable parecer haber sido movida a la cima de la función o código global.
+
+```js
+bla = 2;
+var bla;
+// ...
+
+// Es entendido implicitamente como:
+
+var bla;
+bla = 2;
+```
+
+Por esa razón, se recomienda siempre declarar variables al inicio de su ámbito (la cima del código global y la cima del código de función) para que sea claro cuáles variables pertenecen al ámbito de función (local) y cuáles son resueltas en la cadena de ámbito.
+
+Es importante señalar que **la elevación afectará la declaración** de variables, pero **no su inicialización**. El valor será asignado precisamente cuando la sentencia de asignación sea alcanzada:
+
+```js
+function haz_algo() {
+ console.log(bar); // undefined (valor indefinido)
+ var bar = 111;
+ console.log(bar); // 111
+}
+
+// Se entiende implícitamente como:
+function haz_algo() {
+ var bar;
+ console.log(bar); // undefined (valor indefinido)
+ bar = 111;
+ console.log(bar); // 111
+}
+```
+
+## Ejemplos
+
+### Declarando e inicializando dos variables
+
+```js
+var a = 0, b = 0;
+```
+
+### Asignando dos variables con un solo valor de cadena
+
+```js
+var a = 'A';
+var b = a;
+
+// Equivalente a:
+
+var a, b = a = 'A';
+```
+
+Sé consciente del orden:
+
+```js
+var x = y, y = 'A';
+console.log(x + y); // Imprimirá "undefinedA"
+```
+
+Aquí, '`x`' & '`y`' son declaradas antes de ejecutarse cualquier código, y la asignación ocurre después. Al momento de evaluar "`x = y`", '`y`' existe así que ningún error "`ReferenceError`" es lanzado y su valor es '`undefined`', de modo que '`x`' también tiene asignada el valor '`undefined`'. Después, a 'y' se le asigna el valor 'A'. Consecuentemente, luego de la primera línea, '`x`' es exactamente igual a `'undefined`' & '`y`' es igual a `'A'`, de ahí el resultado.
+
+### Initialización de muchas variables
+
+```js
+var x = 0;
+
+function f() {
+ var x = y = 1; // 'x' es declarada localmente, ¡'y' no lo es!
+}
+f();
+
+console.log(x, y); // Lanza un error de tipo "ReferenceError" en modo estricto ('y' no está definida). De lo contrario se imprimiría "0, 1".
+// En modo no-estricto:
+// 'x' es la variable global como se esperaría
+// 'y' sin embargo, se sale de la función
+```
+
+### Globales implícitas y ámbito externo a una función
+
+Las variables que parecen ser globales implícitas pueden ser referencias a variables en un ámbito externo a la función:
+
+```js
+var x = 0; // 'x' es declarada globalmente, luego se le asigna el valor 0.
+
+console.log(typeof z); // Imprime "undefined", pues 'z' aún no existe.
+
+function a() { // Cuando 'a()' es invocada,
+ var y = 2; // 'y' es declarada localmente en la function 'a()', después se le asigna el valor 2.
+
+ console.log(x, y); // Imprime "0, 2".
+
+ function b() { // Cuando 'b()' es invocada,
+ x = 3; // Asigna el valor 3 a la global 'x' ya existente, no crea una nueva variable global.
+ y = 4; // Asigna 4 a la externa existente 'y', no crea una nueva variable global.
+ z = 5; // Crea una nueva variable global 'z' y le asigna un valor de 5.
+ } // (Lanza un error de tipo "ReferenceError" en modo estricto.)
+
+ b(); // Invocar 'b()' crea 'z' como variable global.
+ console.log(x, y, z); // Imprime "3, 4, 5".
+}
+
+a(); // Invocar 'a()' también llama a 'b()'.
+console.log(x, z); // Imprime "3, 5", porque 'z' ya es una global.
+console.log(typeof y); // Imprime 'undefined' porque 'y' es local en la función 'a()'
+```
diff --git a/files/es/web/javascript/reference/statements/while/index.html b/files/es/web/javascript/reference/statements/while/index.html
deleted file mode 100644
index babb025e1ae22e..00000000000000
--- a/files/es/web/javascript/reference/statements/while/index.html
+++ /dev/null
@@ -1,59 +0,0 @@
----
-title: while
-slug: Web/JavaScript/Reference/Statements/while
-tags:
- - JavaScript
- - Statement
-translation_of: Web/JavaScript/Reference/Statements/while
-original_slug: Web/JavaScript/Referencia/Sentencias/while
----
-{{jsSidebar("Statements")}}
-
-Resumen
-
-Crea un bucle que ejecuta una sentencia especificada mientras cierta condición se evalúe como verdadera. Dicha condición es evaluada antes de ejecutar la sentencia
-
-Sintaxis
-
-while (condicion)
- sentencia
-
-
-
- condicion- Una expresión que se evalúa antes de cada paso del bucle. Si esta condición se evalúa como verdadera, se ejecuta
sentencia. Cuando la condición se evalúa como false, la ejecución continúa con la sentencia posterior al bucle while.
-
-
-
- sentencia- Una sentecia que se ejecuta mientras la condición se evalúa como verdadera. Para ejecutar múltiples sentencias dentro de un bucle, utiliza una sentencia {{jsxref("Sentencias/block", "block")}} (
{ ... }) para agrupar esas sentencias.
-
-
-Ejemplos
-
-El siguiente bucle while itera mientras n es menor que tres.
-
-n = 0;
-x = 0;
-while (n < 3) {
- n ++;
- x += n;
-}
-
-
-Cada interación, el bucle incrementa n y la añade a x. Por lo tanto, x y n toman los siguientes valores:
-
-
- - Después del primer pase:
n = 1 y x = 1
- - Después del segundo pase:
n = 2 y x = 3
- - Después del tercer pase:
n = 3 y x = 6
-
-
-Después de completar el tercer pase, la condición n < 3 no será verdadera más tiempo, por lo que el bucle terminará.
-
-Vea También
-
-
- - {{jsxref("Sentencias/do...while", "do...while")}}
- - {{jsxref("Sentencias/for", "for")}}
-
diff --git a/files/es/web/javascript/reference/statements/while/index.md b/files/es/web/javascript/reference/statements/while/index.md
new file mode 100644
index 00000000000000..b49440c47812b1
--- /dev/null
+++ b/files/es/web/javascript/reference/statements/while/index.md
@@ -0,0 +1,51 @@
+---
+title: while
+slug: Web/JavaScript/Reference/Statements/while
+tags:
+ - JavaScript
+ - Statement
+translation_of: Web/JavaScript/Reference/Statements/while
+original_slug: Web/JavaScript/Referencia/Sentencias/while
+---
+{{jsSidebar("Statements")}}
+
+## Resumen
+
+Crea un bucle que ejecuta una sentencia especificada mientras cierta condición se evalúe como verdadera. Dicha condición es evaluada antes de ejecutar la sentencia
+
+## Sintaxis
+
+ while (condicion)
+ sentencia
+
+- `condicion`
+ - : Una expresión que se evalúa antes de cada paso del bucle. Si esta condición se evalúa como verdadera, se ejecuta `sentencia`. Cuando la condición se evalúa como false, la ejecución continúa con la `sentencia `posterior al bucle `while`.
+
+- `sentencia`
+ - : Una sentecia que se ejecuta mientras la condición se evalúa como verdadera. Para ejecutar múltiples sentencias dentro de un bucle, utiliza una sentencia {{jsxref("Sentencias/block", "block")}} (`{ ... }`) para agrupar esas sentencias.
+
+## Ejemplos
+
+El siguiente bucle `while` itera mientras `n` es menor que tres.
+
+```js
+n = 0;
+x = 0;
+while (n < 3) {
+ n ++;
+ x += n;
+}
+```
+
+Cada interación, el bucle incrementa `n` y la añade a `x`. Por lo tanto, `x` y `n` toman los siguientes valores:
+
+- Después del primer pase: `n` = 1 y `x` = 1
+- Después del segundo pase: `n` = 2 y `x` = 3
+- Después del tercer pase: `n` = 3 y `x` = 6
+
+Después de completar el tercer pase, la condición `n` < 3 no será verdadera más tiempo, por lo que el bucle terminará.
+
+## Vea También
+
+- {{jsxref("Sentencias/do...while", "do...while")}}
+- {{jsxref("Sentencias/for", "for")}}
