diff --git a/1-js/02-first-steps/12-while-for/article.md b/1-js/02-first-steps/12-while-for/article.md
@@ -1,54 +1,54 @@
-# Loops: while and for

-We often need to repeat actions.

-For example, outputting goods from a list one after another or just running the same code for each number from 1 to 10.

-*Loops* are a way to repeat the same code multiple times.

-## The "while" loop

-The `while` loop has the following syntax:

```js
-while (condition) {
-  // code
-  // so-called "loop body"
}
```

-While the `condition` is truthy, the `code` from the loop body is executed.

-For instance, the loop below outputs `i` while `i < 3`:

```js run
let i = 0;
-while (i < 3) { // shows 0, then 1, then 2
  alert( i );
  i++;
}
```

-A single execution of the loop body is called *an iteration*. The loop in the example above makes three iterations.

-If `i++` was missing from the example above, the loop would repeat (in theory) forever. In practice, the browser provides ways to stop such loops, and in server-side JavaScript, we can kill the process.

-Any expression or variable can be a loop condition, not just comparisons: the condition is evaluated and converted to a boolean by `while`.

-For instance, a shorter way to write `while (i != 0)` is `while (i)`:

```js run
let i = 3;
*!*
-while (i) { // when i becomes 0, the condition becomes falsy, and the loop stops
*/!*
  alert( i );
  i--;
}
```

````smart header="Curly braces are not required for a single-line body"
-If the loop body has a single statement, we can omit the curly braces `{…}`:

```js run
let i = 3;
@@ -58,19 +58,19 @@ while (i) alert(i--);
```
````

-## The "do..while" loop

-The condition check can be moved *below* the loop body using the `do..while` syntax:

```js
do {
-  // loop body
-} while (condition);
```

-The loop will first execute the body, then check the condition, and, while it's truthy, execute it again and again.

-For example:

```js run
let i = 0;
@@ -80,65 +80,64 @@ do {
} while (i < 3);
```

-This form of syntax should only be used when you want the body of the loop to execute **at least once** regardless of the condition being truthy. Usually, the other form is preferred: `while(…) {…}`.

-## The "for" loop

-The `for` loop is more complex, but it's also the most commonly used loop.

-It looks like this:

```js
-for (begin; condition; step) {
-  // ... loop body ...
}
```

-Let's learn the meaning of these parts by example. The loop below runs `alert(i)` for `i` from `0` up to (but not including) `3`:

```js run
-for (let i = 0; i < 3; i++) { // shows 0, then 1, then 2
  alert(i);
}
```

-Let's examine the `for` statement part-by-part:

-| part  |          |                                                                            |
|-------|----------|----------------------------------------------------------------------------|
-| begin | `i = 0`    | Executes once upon entering the loop.                                      |
-| condition | `i < 3`| Checked before every loop iteration. If false, the loop stops.              |
-| body | `alert(i)`| Runs again and again while the condition is truthy.                         |
-| step| `i++`      | Executes after the body on each iteration. |
-
-The general loop algorithm works like this:

```
-Run begin
-→ (if condition → run body and run step)
-→ (if condition → run body and run step)
-→ (if condition → run body and run step)
→ ...
```

That is, `begin` executes once, and then it iterates: after each `condition` test, `body` and `step` are executed.

If you are new to loops, it could help to go back to the example and reproduce how it runs step-by-step on a piece of paper.

-Here's exactly what happens in our case:

```js
// for (let i = 0; i < 3; i++) alert(i)

-// run begin
let i = 0
-// if condition → run body and run step
if (i < 3) { alert(i); i++ }
-// if condition → run body and run step
if (i < 3) { alert(i); i++ }
-// if condition → run body and run step
if (i < 3) { alert(i); i++ }
-// ...finish, because now i == 3
```

````smart header="Inline variable declaration"