From 7858327344a4ba0c354b10b34f301c3d77605beb Mon Sep 17 00:00:00 2001
From: wbamberg <will@bootbonnet.ca>
Date: Sun, 28 Nov 2021 16:17:45 -0800
Subject: [PATCH] JS Learning Area updates: looping code (#10645)

---
 .../building_blocks/looping_code/index.md     | 564 ++++++++++++------
 .../looping_code/loop_js-02-farm.png          | Bin 41232 -> 0 bytes
 .../test_your_skills_colon__loops/index.md    |   4 +-
 3 files changed, 369 insertions(+), 199 deletions(-)
 delete mode 100644 files/en-us/learn/javascript/building_blocks/looping_code/loop_js-02-farm.png

diff --git a/files/en-us/learn/javascript/building_blocks/looping_code/index.md b/files/en-us/learn/javascript/building_blocks/looping_code/index.md
index a676723ca4d9e7e..0b8dc239c61b834 100644
--- a/files/en-us/learn/javascript/building_blocks/looping_code/index.md
+++ b/files/en-us/learn/javascript/building_blocks/looping_code/index.md
@@ -38,114 +38,75 @@ Programming languages are very useful for rapidly completing repetitive tasks, f
   </tbody>
 </table>
 
-## Keep me in the loop
+## Why are loops useful?
 
-Loops, loops, loops. As well as being associated with [popular breakfast cereals](https://en.wikipedia.org/wiki/Froot_Loops), [roller coasters](https://en.wikipedia.org/wiki/Vertical_loop), and [musical production](<https://en.wikipedia.org/wiki/Loop_(music)>), they are also a critical concept in programming. Programming loops are all to do with doing the same thing over and over again, which is termed **iteration** in programming speak.
+Loops are all about doing the same thing over and over again. Often, the code will be slightly different each time round the loop, or the same code will run but with different variables.
 
-Let's consider the case of a farmer who is making sure he has enough food to feed his family for the week. He might use the following loop to achieve this:
+### Looping code example
 
-![](loop_js-02-farm.png)
+Suppose we wanted to draw 100 random circles on a {{htmlelement("canvas")}} element (press the _Update_ button to run the example again and again to see different random sets):
 
-A loop usually has one or more of the following features:
-
-- A **counter**, which is initialized with a certain value — this is the starting point of the loop ("Start: I have no food", above).
-- A **condition**, which is a true/false test to determine whether the loop continues to run, or stops — usually when the counter reaches a certain value. This is illustrated by "Have I got enough food?" above. Let's say he needs 10 portions of food to feed his family.
-- An **iterator**, which generally increments the counter by a small amount on each successive loop until the condition is no longer `true`. We haven't explicitly illustrated this above, but we could think about the farmer being able to collect say 2 portions of food per hour. After each hour, the amount of food he has collected is incremented by two, and he checks whether he has enough food. If he has reached 10 portions (the point where the condition is no longer true, so the loop exits), he can stop collecting and go home.
+```html hidden
+<button>Update</button>
+<canvas></canvas>
+```
 
-In {{glossary("pseudocode")}}, this would look something like the following:
+```css hidden
+html {
+  width: 100%;
+  height: inherit;
+  background: #ddd;
+}
 
-    loop(food = 0; foodNeeded = 10) {
-      if (food >= foodNeeded) {
-        exit loop;
-        // We have enough food; let's go home
-      } else {
-        food += 2; // Spend an hour collecting 2 more food
-        // loop will then run again
-      }
-    }
+canvas {
+  display: block;
+}
 
-So the amount of food needed is set at 10, and the amount the farmer currently has is set at 0. In each iteration of the loop, we check whether the amount of food the farmer has is larger or equal to the amount he needs. If so, we can exit the loop. If not, the farmer spends an hour collecting two portions of food and the loop runs again.
+body {
+  margin: 0;
+}
 
-### Why bother?
+button {
+  position: absolute;
+  top: 5px;
+  left: 5px;
+}
+```
 
-At this point, you probably understand the high-level concepts behind loops, but you are probably thinking "OK, great, but how does this help me write better JavaScript code?" As we said earlier, **loops are all to do with doing the same thing over and over again**, which is great for **rapidly completing repetitive tasks**.
+{{ EmbedLiveSample('Looping_code_example', '100%', 400) }}
 
-Often, the code will be slightly different on each successive iteration of the loop, which means that you can complete a whole load of tasks that are similar but slightly different; if you've got a lot of different calculations to do, you want to do each different one, not the same one over and over again!
+Here's the JavaScript code that implements this example:
 
-#### Looping code example
 
-Let's look at an example to illustrate why loops are such a good thing. Let's say we wanted to draw 100 random circles on a {{htmlelement("canvas")}} element (press the _Update_ button to run the example again and again to see different random sets):
+```js
+const btn = document.querySelector('button');
+const canvas = document.querySelector('canvas');
+const ctx = canvas.getContext('2d');
 
-```html hidden
-<!DOCTYPE html>
-<html>
-  <head>
-    <meta charset="utf-8">
-    <title>Random canvas circles</title>
-    <style>
-      html {
-        width: 100%;
-        height: inherit;
-        background: #ddd;
-      }
-
-      canvas {
-        display: block;
-      }
-
-      body {
-        margin: 0;
-      }
-
-      button {
-        position: absolute;
-        top: 5px;
-        left: 5px;
-      }
-    </style>
-  </head>
-  <body>
-
-  <button>Update</button>
-
-  <canvas></canvas>
-
-    <script>
-    const btn = document.querySelector('button');
-    const canvas = document.querySelector('canvas');
-    const ctx = canvas.getContext('2d');
-
-    let WIDTH = document.documentElement.clientWidth;
-    let HEIGHT = document.documentElement.clientHeight;
-
-    canvas.width = WIDTH;
-    canvas.height = HEIGHT;
-
-    function random(number) {
-      return Math.floor(Math.random()*number);
-    }
+const WIDTH = document.documentElement.clientWidth;
+const HEIGHT = document.documentElement.clientHeight;
 
-    function draw() {
-      ctx.clearRect(0,0,WIDTH,HEIGHT);
-      for (let i = 0; i < 100; i++) {
-        ctx.beginPath();
-        ctx.fillStyle = 'rgba(255,0,0,0.5)';
-        ctx.arc(random(WIDTH), random(HEIGHT), random(50), 0, 2 * Math.PI);
-        ctx.fill();
-      }
-    }
+canvas.width = WIDTH;
+canvas.height = HEIGHT;
 
-    btn.addEventListener('click',draw);
+function random(number) {
+  return Math.floor(Math.random()*number);
+}
 
-    </script>
+function draw() {
+  ctx.clearRect(0,0,WIDTH,HEIGHT);
+  for (let i = 0; i < 100; i++) {
+    ctx.beginPath();
+    ctx.fillStyle = 'rgba(255,0,0,0.5)';
+    ctx.arc(random(WIDTH), random(HEIGHT), random(50), 0, 2 * Math.PI);
+    ctx.fill();
+  }
+}
 
-  </body>
-</html>
+btn.addEventListener('click',draw);
 ```
 
-{{ EmbedLiveSample('Looping_code_example', '100%', 400) }}
-
-#### With and without a loop
+### With and without a loop
 
 You don't have to understand all the code for now, but let's look at the part of the code that actually draws the 100 circles:
 
@@ -161,7 +122,9 @@ for (let i = 0; i < 100; i++) {
 - `random(x)`, defined earlier in the code, returns a whole number between `0` and `x-1`.
 - `WIDTH` and `HEIGHT` are the width and height of the inner browser window.
 
-You should get the basic idea — we are using a loop to run 100 iterations of this code, each one of which draws a circle in a random position on the page. The amount of code needed would be the same whether we were drawing 100 circles, 1000, or 10,000. Only one number has to change.
+You should get the basic idea — we are using a loop to run 100 iterations of this code, each one of which draws a circle in a random position on the page.
+The amount of code needed would be the same whether we were drawing 100 circles, 1000, or 10,000.
+Only one number has to change.
 
 If we weren't using a loop here, we'd have to repeat the following code for every circle we wanted to draw:
 
@@ -172,110 +135,253 @@ ctx.arc(random(WIDTH), random(HEIGHT), random(50), 0, 2 * Math.PI);
 ctx.fill();
 ```
 
-This would get very boring and difficult to maintain very quickly. Loops really are the best.
+This would get very boring and difficult to maintain.
 
-## The standard for loop
+## Looping through a collection
 
-Let's start exploring some specific loop constructs. The first, which you'll use most of the time, is the [for](/en-US/docs/Web/JavaScript/Reference/Statements/for) loop. This has the following syntax:
+Most of the time when you use a loop, you will have a collection of items and want to do something with every item.
 
-    for (initializer; condition; final-expression) {
-      // code to run
-    }
+One type of collection is the {{jsxref("Array")}}, which we met in the [Arrays](/en-US/docs/Learn/JavaScript/First_steps/Arrays) chapter of this course.
+But there are other collections in JavaScript as well, including {{jsxref("Set")}} and {{jsxref("Map")}}.
+
+### The for...of loop
+
+The basic tool for looping through a collection is the {{jsxref("statements/for...of","for...of")}} loop:
+
+```js
+const cats = ['Leopard', 'Serval', 'Jaguar', 'Tiger', 'Caracal', 'Lion'];
+
+for (const cat of cats) {
+  console.log(cat);
+}
+```
+
+In this example, `for (const cat of cats)` says:
+
+1. Given the collection `cats`, get the first item in the collection.
+2. Assign it to the variable `cat` and then run the code between the curly brackets `{}`.
+3. Get the next item, and repeat (2) until you've reached the end of the collection.
+
+### map() and filter()
+
+JavaScript also has more specialized loops for collections, and we'll mention two of them here.
+
+You can use `map()` to do something to each item in a collection and create a new collection containing the changed items:
+
+```js
+function toUpper(string) {
+  return string.toUpperCase();
+}
+
+const cats = ['Leopard', 'Serval', 'Jaguar', 'Tiger', 'Caracal', 'Lion'];
+
+const upperCats = cats.map(toUpper);
+
+console.log(upperCats);
+// [ "LEOPARD", "SERVAL", "JAGUAR", "TIGER", "CARACAL", "LION" ]
+```
+
+Here we pass a function into {{jsxref("Array.prototype.map()","cats.map()")}}, and `map()` calls the function once for each item in the array, passing in the item. It then adds the return value from each function call to a new array, and finally returns the new array. In this case the function we provide converts the item to uppercase, so the resulting array contains all our cats in uppercase:
+
+```
+[ "LEOPARD", "SERVAL", "JAGUAR", "TIGER", "CARACAL", "LION" ]
+```
+
+You can use {{jsxref("Array.prototype.filter()","filter()")}} to test each item in a collection, and create a new collection containing only items that match:
+
+```js
+function lCat(cat) {
+  return cat.startsWith('L');
+}
+
+const cats = ['Leopard', 'Serval', 'Jaguar', 'Tiger', 'Caracal', 'Lion'];
+
+const filtered = cats.filter(lCat);
+
+console.log(filtered);
+// [ "Leopard", "Lion" ]
+```
+
+This looks a lot like `map()`, except the function we pass in returns a [boolean](/en-US/docs/Learn/JavaScript/First_steps/Variables#booleans): if it returns `true`, then the item is included in the new array.
+Our function tests that the item starts with the letter "L", so the result is an array containing only cats whose names start with "L":
+
+```
+[ "Leopard", "Lion" ]
+```
 
+Note that `map()` and `filter()` are both often used with _function expressions_, which we will learn about in the [Functions](/en-US/docs/Learn/JavaScript/Building_blocks/Functions) module.
+Using function expressions we could rewrite the example above to be much more compact:
+
+```js
+const cats = ['Leopard', 'Serval', 'Jaguar', 'Tiger', 'Caracal', 'Lion'];
+
+const filtered = cats.filter((cat) => cat.startsWith('L'));
+console.log(filtered);
+// [ "Leopard", "Lion" ]
+```
+
+## The standard for loop
+
+In the "drawing circles" example above, you don't have a collection of items to loop through: you really just want to run the same code 100 times.
+In a case like that you should use the {{jsxref("statements/for","for")}} loop.
+This has the following syntax:
+
+```js
+for (initializer; condition; final-expression) {
+  // code to run
+}
+```
 Here we have:
 
-1.  The keyword `for`, followed by some parentheses.
-2.  Inside the parentheses we have three items, separated by semi-colons:
+1. The keyword `for`, followed by some parentheses.
+2. Inside the parentheses we have three items, separated by semi-colons:
 
-    1.  An **initializer** — this is usually a variable set to a number, which is incremented to count the number of times the loop has run. It is also sometimes referred to as a **counter variable**.
-    2.  A **condition** — as mentioned before, this defines when the loop should stop looping. This is generally an expression featuring a comparison operator, a test to see if the exit condition has been met.
-    3.  A **final-expression** — this is always evaluated (or run) each time the loop has gone through a full iteration. It usually serves to increment (or in some cases decrement) the counter variable, to bring it closer to the point where the condition is no longer `true`.
+   1. An **initializer** — this is usually a variable set to a number, which is incremented to count the number of times the loop has run.
+      It is also sometimes referred to as a **counter variable**.
+   3. A **condition** — this defines when the loop should stop looping.
+      This is generally an expression featuring a comparison operator, a test to see if the exit condition has been met.
+   5. A **final-expression** — this is always evaluated (or run) each time the loop has gone through a full iteration.
+      It usually serves to increment (or in some cases decrement) the counter variable, to bring it closer to the point where the condition is no longer `true`.
 
-3.  Some curly braces that contain a block of code — this code will be run each time the loop iterates.
+3. Some curly braces that contain a block of code — this code will be run each time the loop iterates.
 
-### Listing my cats
+### Calculating squares
 
 Let's look at a real example so we can visualize what these do more clearly.
 
 ```html hidden
-  <p></p>
+<button id="calculate">Calculate</button>
+<button id="clear">Clear</button>
+<pre id="results"></pre>
 ```
 
 ```js
-const cats = ['Bill', 'Jeff', 'Pete', 'Biggles', 'Jasmin'];
-let info = 'My cats are called ';
-const para = document.querySelector('p');
+const results = document.querySelector('#results');
 
-for (let i = 0; i < cats.length; i++) {
-  info += cats[i] + ', ';
+function calculate() {
+  for (let i = 1; i < 10; i++) {
+    const newResult = `${i} x ${i} = ${i * i}`;
+    results.textContent += `${newResult}\n`;
+  }
+  results.textContent += '\n...finished!';
 }
 
-para.textContent = info;
+const calculateBtn = document.querySelector('#calculate');
+const clearBtn = document.querySelector('#clear');
+
+calculateBtn.addEventListener('click', calculate);
+clearBtn.addEventListener('click', () => results.textContent = '');
+
 ```
 
 This gives us the following output:
 
-{{ EmbedLiveSample('Listing_my_cats', '100%', 80) }}
+{{ EmbedLiveSample('Calculating squares', '100%', 250) }}
 
-> **Note:** You can find this [example code on GitHub](https://github.com/mdn/learning-area/blob/master/javascript/building-blocks/loops/basic-for.html) too (also [see it running live](https://mdn.github.io/learning-area/javascript/building-blocks/loops/basic-for.html)).
+This code calculates squares for the numbers from 1 to 9, and writes out the result. The core of the code is the `for` loop that performs the calculation.
 
-This shows a loop is used to iterate over the items in an array and do something with each of them — a very common pattern in JavaScript. Here:
+Let's break down the `for (let i = 1; i < 10; i++)` line into its three pieces:
 
-1.  The counter variable (sometimes known as an initializer or an iteration variable), `i`, starts at `0` (`let i = 0`).
-2.  The loop has been told to run until `i` is no longer smaller than the length of the `cats` array. This is important — the condition is the condition under which the loop will still run. So in this case, while `i < cats.length` is still true, the loop will still run.
-3.  Inside the loop, we concatenate the current loop item (`cats[i]` , which is `cats[whatever i is at the time]`) along with a comma and space, onto the end of the `info` variable. So:
+1. `let i = 1`: the counter variable, `i`, starts at `1`. Note that we have to use `let` for the counter, because we're reassigning it each time we go round the loop.
+2. `i < 10`: keep going round the loop for as long as `i` is smaller than `10`.
+3. `i++`: add one to `i` each time round the loop.
 
-    1.  During the first run, `i = 0`, therefore `cats[0] + ', '` (which is equal to `Bill, `) will be concatenated onto `info`.
-    2.  During the second run, `i = 1`, so `cats[1] + ', '` (which is equal to `Jeff, `) will be concatenated onto `info`.
-    3.  And so on. After each time the loop has run, 1 will be added to `i` (`i++`), then the process will start again.
+Inside the loop, we calculate the square of the current value of `i`, that is: `i * i`. We create a string expressing the calculation we made and the result, and add this string to the output text. We also add `\n`, so the next string we add will begin on a new line. So:
 
-4.  When `i` becomes equal to `cats.length` (in this case, 5), the loop will stop, and the browser will move on to the next bit of code below the loop.
+1. During the first run, `i = 1`, so we will add `1 x 1 = 1`.
+2. During the second run, `i = 2`, so we will add `2 x 2 = 4`.
+3. ...and so on.
+4. When `i` becomes equal to `10` we will stop running the loop and move straight to the next bit of code below the loop, printing out the `...finished!` message.
 
-> **Note:** We have made the condition `i < cats.length`, not `i <= cats.length`, because computers count from 0, not 1 — we are starting `i` at `0`, and going up to `i = 4` (the index of the last array item). `cats.length` returns 5, as there are 5 items in the array, but we don't want to get up to `i = 5`, as that would return `undefined` for the last item (there is no array item with an index of 5). So, therefore, we want to go up to 1 less than `cats.length` (`i <`), not the same as `cats.length` (`i <=`).
+### Looping through collections with a for loop
 
-> **Note:** A common mistake with conditions is making them use "equal to" (`===`) rather than say "less than or equal to" (`<=`). If we wanted to run our loop up to `i = 5`, the exit condition would need to be `i <= cats.length`. If we set it to `i === cats.length`, the loop would not run at all because `i` is not equal to `5` on the first loop iteration, so it would stop immediately.
+You can use a `for` loop to iterate through a collection, instead of a `for...of` loop.
 
-### Handling the last cat
+Let's look again at our `for...of` example above:
 
-One small problem we are left with is that the final output sentence isn't very well-formed:
+```js
+const cats = ['Leopard', 'Serval', 'Jaguar', 'Tiger', 'Caracal', 'Lion'];
 
-> My cats are called Bill, Jeff, Pete, Biggles, Jasmin,
+for (const cat of cats) {
+  console.log(cat);
+}
+```
 
-Ideally, we want to change the concatenation on the final loop iteration so that we haven't got a comma on the end of the sentence. Well, no problem — we can quite happily insert a conditional inside our for loop to handle this special case:
+We could rewrite that code like this:
 
-```html hidden
-  <p></p>
+```js
+const cats = ['Leopard', 'Serval', 'Jaguar', 'Tiger', 'Caracal', 'Lion'];
+
+for (let i = 0; i < cats.length; i++) {
+  console.log(cats[i]);
+}
 ```
 
+In this loop we're starting `i` at `0`, and stopping when `i` reaches the length of the array.
+Then inside the loop we're using `i` to access each item in the array in turn.
+
+This works just fine, and in early versions of JavaScript, `for...of` didn't exist, so this was the standard way to iterate through an array.
+However, it offers more chances to introduce bugs into your code. For example:
+
+* you might start `i` at `1`, forgetting that the first array index is zero, not 1.
+* you might stop at `i <= cats.length`, forgetting that the last array index is at `length - 1`.
+
+For reasons like this, it's usually best to use `for...of` if you can.
+
+Sometimes you still need to use a `for` loop to iterate through an array.
+For example, in the code below we want to log a message listing our cats:
+
 ```js
-const cats = ['Bill', 'Jeff', 'Pete', 'Biggles', 'Jasmin'];
-let info = 'My cats are called ';
-const para = document.querySelector('p');
+const cats = ['Pete', 'Biggles', 'Jasmin'];
 
-for (let i = 0; i < cats.length; i++) {
-  if (i === cats.length - 1) {
-    info += 'and ' + cats[i] + '.';
-  } else {
-    info += cats[i] + ', ';
-  }
+let myFavoriteCats = 'My cats are called ';
+
+for (const cat of cats) {
+  myFavoriteCats = `${myFavoriteCats}${cat}, `
 }
 
-para.textContent = info;
+console.log(myFavoriteCats); // "My cats are called Pete, Biggles, Jasmin, "
+```
+
+The final output sentence isn't very well-formed:
+
+```
+My cats are called Pete, Biggles, Jasmin,
 ```
 
-{{ EmbedLiveSample('Handling_the_last_cat', '100%', 80) }}
+We'd prefer it to handle the last cat differently, like this:
 
-> **Note:** You can find this [example code on GitHub](https://github.com/mdn/learning-area/blob/master/javascript/building-blocks/loops/basic-for-improved.html) too (also [see it running live](https://mdn.github.io/learning-area/javascript/building-blocks/loops/basic-for-improved.html)).
+```
+My cats are called Pete, Biggles, and Jasmin.
+```
 
-> **Warning:** With for — as with all loops — you must make sure that the initializer is incremented or, depending on the case, decremented, so that it eventually reaches the point where the condition is not true. If not, the loop will go on forever, and either the browser will force it to stop, or it will crash. This is called an **infinite loop**.
+But to do this we need to know when we are on the final loop iteration, and to do that we can use a `for` loop and examine the value of `i`:
+
+```js
+const cats = ['Pete', 'Biggles', 'Jasmin'];
+
+let myFavoriteCats = 'My cats are called ';
+
+for (let i = 0; i < cats.length; i++) {
+  if (i === cats.length - 1) {   // We are at the end of the array
+    myFavoriteCats = `${myFavoriteCats}and ${cats[i]}.`
+  } else {
+    myFavoriteCats = `${myFavoriteCats}${cats[i]}, `
+  }
+}
+
+console.log(myFavoriteCats);     // "My cats are called Pete, Biggles, and Jasmin."
+```
 
 ## Exiting loops with break
 
-If you want to exit a loop before all the iterations have been completed, you can use the [break](/en-US/docs/Web/JavaScript/Reference/Statements/break) statement. We already met this in the previous article when we looked at [switch statements](/en-US/docs/Learn/JavaScript/Building_blocks/conditionals#switch_statements) — when a case is met in a switch statement that matches the input expression, the `break` statement immediately exits the switch statement and moves on to the code after it.
+If you want to exit a loop before all the iterations have been completed, you can use the [break](/en-US/docs/Web/JavaScript/Reference/Statements/break) statement.
+We already met this in the previous article when we looked at [switch statements](/en-US/docs/Learn/JavaScript/Building_blocks/conditionals#switch_statements) — when a case is met in a switch statement that matches the input expression, the `break` statement immediately exits the switch statement and moves on to the code after it.
 
 It's the same with loops — a `break` statement will immediately exit the loop and make the browser move on to any code that follows it.
 
-Say we wanted to search through an array of contacts and telephone numbers and return just the number we wanted to find? First, some simple HTML — a text {{htmlelement("input")}} allowing us to enter a name to search for, a {{htmlelement("button")}} element to submit a search, and a {{htmlelement("p")}} element to display the results in:
+Say we wanted to search through an array of contacts and telephone numbers and return just the number we wanted to find?
+First, some simple HTML — a text {{htmlelement("input")}} allowing us to enter a name to search for, a {{htmlelement("button")}} element to submit a search, and a {{htmlelement("p")}} element to display the results in:
 
 ```html
 <label for="search">Search by contact name: </label>
@@ -294,39 +400,43 @@ const input = document.querySelector('input');
 const btn = document.querySelector('button');
 
 btn.addEventListener('click', function() {
-  let searchName = input.value.toLowerCase();
+  const searchName = input.value.toLowerCase();
   input.value = '';
   input.focus();
-  for (let i = 0; i < contacts.length; i++) {
-    let splitContact = contacts[i].split(':');
+  para.textContent = '';
+  for (const contact of contacts) {
+    const splitContact = contact.split(':');
     if (splitContact[0].toLowerCase() === searchName) {
       para.textContent = splitContact[0] + '\'s number is ' + splitContact[1] + '.';
       break;
-    } else if (i === contacts.length-1) {
-      para.textContent = 'Contact not found.';
     }
   }
+  if (para.textContent === '') {
+   para.textContent = 'Contact not found.';
+ }
 });
 ```
 
 {{ EmbedLiveSample('Exiting_loops_with_break', '100%', 100) }}
 
-1.  First of all, we have some variable definitions — we have an array of contact information, with each item being a string containing a name and phone number separated by a colon.
-2.  Next, we attach an event listener to the button (`btn`) so that when it is pressed some code is run to perform the search and return the results.
-3.  We store the value entered into the text input in a variable called `searchName`, before then emptying the text input and focusing it again, ready for the next search. Note that we also run the [`toLowerCase()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase) method on the string, so that searches will be case-insensitive.
-4.  Now on to the interesting part, the for loop:
+1. First of all, we have some variable definitions — we have an array of contact information, with each item being a string containing a name and phone number separated by a colon.
+2. Next, we attach an event listener to the button (`btn`) so that when it is pressed some code is run to perform the search and return the results.
+3. We store the value entered into the text input in a variable called `searchName`, before then emptying the text input and focusing it again, ready for the next search.
+   Note that we also run the [`toLowerCase()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase) method on the string, so that searches will be case-insensitive.
+5. Now on to the interesting part, the `for...of` loop:
 
-    1.  We start the counter at `0`, run the loop until the counter is no longer less than `contacts.length`, and increment `i` by 1 after each iteration of the loop.
-    2.  Inside the loop, we first split the current contact (`contacts[i]`) at the colon character, and store the resulting two values in an array called `splitContact`.
-    3.  We then use a conditional statement to test whether `splitContact[0]` (the contact's name, again lower-cased with [`toLowerCase()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)) is equal to the inputted `searchName`. If it is, we enter a string into the paragraph to report what the contact's number is, and use `break` to end the loop.
+   1. Inside the loop, we first split the current contact at the colon character, and store the resulting two values in an array called `splitContact`.
+   2. We then use a conditional statement to test whether `splitContact[0]` (the contact's name, again lower-cased with [`toLowerCase()`](/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase)) is equal to the inputted `searchName`.
+      If it is, we enter a string into the paragraph to report what the contact's number is, and use `break` to end the loop.
 
-5.  After `(contacts.length-1)` iterations, if the contact name does not match the entered search the paragraph text is set to "Contact not found.", and the loop continues looping until the condition is no longer true.
+4. After the loop, we check whether we set a contact, and if not we set the paragraph text to "Contact not found.".
 
 > **Note:** You can view the [full source code on GitHub](https://github.com/mdn/learning-area/blob/master/javascript/building-blocks/loops/contact-search.html) too (also [see it running live](https://mdn.github.io/learning-area/javascript/building-blocks/loops/contact-search.html)).
 
 ## Skipping iterations with continue
 
-The [continue](/en-US/docs/Web/JavaScript/Reference/Statements/continue) statement works in a similar manner to `break`, but instead of breaking out of the loop entirely, it skips to the next iteration of the loop. Let's look at another example that takes a number as an input, and returns only the numbers that are squares of integers (whole numbers).
+The [continue](/en-US/docs/Web/JavaScript/Reference/Statements/continue) statement works in a similar manner to `break`, but instead of breaking out of the loop entirely, it skips to the next iteration of the loop.
+Let's look at another example that takes a number as an input, and returns only the numbers that are squares of integers (whole numbers).
 
 The HTML is basically the same as the last example — a simple text input, and a paragraph for output.
 
@@ -364,10 +474,10 @@ Here's the output:
 
 {{ EmbedLiveSample('Skipping_iterations_with_continue', '100%', 100) }}
 
-1.  In this case, the input should be a number (`num`). The `for` loop is given a counter starting at 1 (as we are not interested in 0 in this case), an exit condition that says the loop will stop when the counter becomes bigger than the input `num`, and an iterator that adds 1 to the counter each time.
-2.  Inside the loop, we find the square root of each number using [Math.sqrt(i)](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sqrt), then check whether the square root is an integer by testing whether it is the same as itself when it has been rounded down to the nearest integer (this is what [Math.floor()](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor) does to the number it is passed).
-3.  If the square root and the rounded down square root do not equal one another (`!==`), it means that the square root is not an integer, so we are not interested in it. In such a case, we use the `continue` statement to skip on to the next loop iteration without recording the number anywhere.
-4.  If the square root is an integer, we skip past the `if` block entirely, so the `continue` statement is not executed; instead, we concatenate the current `i` value plus a space on to the end of the paragraph content.
+1. In this case, the input should be a number (`num`). The `for` loop is given a counter starting at 1 (as we are not interested in 0 in this case), an exit condition that says the loop will stop when the counter becomes bigger than the input `num`, and an iterator that adds 1 to the counter each time.
+2. Inside the loop, we find the square root of each number using [Math.sqrt(i)](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sqrt), then check whether the square root is an integer by testing whether it is the same as itself when it has been rounded down to the nearest integer (this is what [Math.floor()](/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor) does to the number it is passed).
+3. If the square root and the rounded down square root do not equal one another (`!==`), it means that the square root is not an integer, so we are not interested in it. In such a case, we use the `continue` statement to skip on to the next loop iteration without recording the number anywhere.
+4. If the square root is an integer, we skip past the `if` block entirely, so the `continue` statement is not executed; instead, we concatenate the current `i` value plus a space on to the end of the paragraph content.
 
 > **Note:** You can view the [full source code on GitHub](https://github.com/mdn/learning-area/blob/master/javascript/building-blocks/loops/integer-squares.html) too (also [see it running live](https://mdn.github.io/learning-area/javascript/building-blocks/loops/integer-squares.html)).
 
@@ -384,24 +494,33 @@ First, let's have a look at the [while](/en-US/docs/Web/JavaScript/Reference/Sta
       final-expression
     }
 
-This works in a very similar way to the `for` loop, except that the initializer variable is set before the loop, and the final-expression is included inside the loop after the code to run, rather than these two items being included inside the parentheses. The condition is included inside the parentheses, which are preceded by the `while` keyword rather than `for`.
+This works in a very similar way to the `for` loop, except that the initializer variable is set before the loop, and the final-expression is included inside the loop after the code to run, rather than these two items being included inside the parentheses.
+The condition is included inside the parentheses, which are preceded by the `while` keyword rather than `for`.
 
-The same three items are still present, and they are still defined in the same order as they are in the for loop. This is because you must have an initializer defined before you can check whether or not the condition is true. The final-expression is then run after the code inside the loop has run (an iteration has been completed), which will only happen if the condition is still true.
+The same three items are still present, and they are still defined in the same order as they are in the for loop.
+This is because you must have an initializer defined before you can check whether or not the condition is true.
+The final-expression is then run after the code inside the loop has run (an iteration has been completed), which will only happen if the condition is still true.
 
 Let's have a look again at our cats list example, but rewritten to use a while loop:
 
 ```js
+const cats = ['Pete', 'Biggles', 'Jasmin'];
+
+let myFavoriteCats = 'My cats are called ';
+
 let i = 0;
 
 while (i < cats.length) {
   if (i === cats.length - 1) {
-    info += 'and ' + cats[i] + '.';
+    myFavoriteCats += `and ${cats[i]}.`;
   } else {
-    info += cats[i] + ', ';
+    myFavoriteCats += `${cats[i]}, `;
   }
 
   i++;
 }
+
+console.log(myFavoriteCats);     // "My cats are called Pete, Biggles, and Jasmin."
 ```
 
 > **Note:** This still works just the same as expected — have a look at it [running live on GitHub](https://mdn.github.io/learning-area/javascript/building-blocks/loops/while.html) (also view the [full source code](https://github.com/mdn/learning-area/blob/master/javascript/building-blocks/loops/while.html)).
@@ -417,34 +536,43 @@ The [do...while](/en-US/docs/Web/JavaScript/Reference/Statements/do...while) loo
 
 In this case, the initializer again comes first, before the loop starts. The keyword directly precedes the curly braces containing the code to run and the final expression.
 
-The differentiator here is that the condition comes after everything else, wrapped in parentheses and preceded by a `while` keyword. In a `do...while` loop, the code inside the curly braces is always run once before the check is made to see if it should be executed again (in while and for, the check comes first, so the code might never be executed).
+The main difference between a `do...while` loop and a `while` loop is that _the code inside a `do...while` loop is always executed at least once_. That's because the condition comes after the code inside the loop. So we always run that code, then check to see if we need to run it again. In `while` and `for` loops, the check comes first, so the code might never be executed.
 
 Let's rewrite our cat listing example again to use a `do...while` loop:
 
 ```js
+const cats = ['Pete', 'Biggles', 'Jasmin'];
+
+let myFavoriteCats = 'My cats are called ';
+
 let i = 0;
 
 do {
   if (i === cats.length - 1) {
-    info += 'and ' + cats[i] + '.';
+    myFavoriteCats += `and ${cats[i]}.`;
   } else {
-    info += cats[i] + ', ';
+    myFavoriteCats += `${cats[i]}, `;
   }
 
   i++;
 } while (i < cats.length);
+
+console.log(myFavoriteCats);     // "My cats are called Pete, Biggles, and Jasmin."
 ```
 
 > **Note:** Again, this works just the same as expected — have a look at it [running live on GitHub](https://mdn.github.io/learning-area/javascript/building-blocks/loops/do-while.html) (also view the [full source code](https://github.com/mdn/learning-area/blob/master/javascript/building-blocks/loops/do-while.html)).
 
-> **Warning:** With while and do...while — as with all loops — you must make sure that the initializer is incremented or, depending on the case, decremented, so the condition eventually becomes false. If not, the loop will go on forever, and either the browser will force it to stop, or it will crash. This is called an **infinite loop**.
+> **Warning:** With while and do...while — as with all loops — you must make sure that the initializer is incremented or, depending on the case, decremented, so the condition eventually becomes false.
+> If not, the loop will go on forever, and either the browser will force it to stop, or it will crash. This is called an **infinite loop**.
 
 ## Active learning: Launch countdown
 
-In this exercise, we want you to print out a simple launch countdown to the output box, from 10 down to Blastoff. Specifically, we want you to:
+In this exercise, we want you to print out a simple launch countdown to the output box, from 10 down to Blastoff.
+Specifically, we want you to:
 
 - Loop from 10 down to 0. We've provided you with an initializer — `let i = 10;`.
-- For each iteration, create a new paragraph and append it to the output `<div>`, which we've selected using `const output = document.querySelector('.output');`. In comments, we've provided you with three code lines that need to be used somewhere inside the loop:
+- For each iteration, create a new paragraph and append it to the output `<div>`, which we've selected using `const output = document.querySelector('.output');`.
+  In comments, we've provided you with three code lines that need to be used somewhere inside the loop:
 
   - `const para = document.createElement('p');` — creates a new paragraph.
   - `output.appendChild(para);` — appends the paragraph to the output `<div>`.
@@ -460,7 +588,8 @@ In this exercise, we want you to print out a simple launch countdown to the outp
 
 > **Note:** If you start typing the loop (for example (while(i>=0)), the browser might stuck because you have not yet entered the end condition. So be careful with this. You can start writing your code in a comment to deal with this issue and remove the comment after you finish.
 
-If you make a mistake, you can always reset the example with the "Reset" button. If you get really stuck, press "Show solution" to see a solution.
+If you make a mistake, you can always reset the example with the "Reset" button.
+If you get really stuck, press "Show solution" to see a solution.
 
 ```html hidden
 <h2>Live output</h2>
@@ -596,7 +725,7 @@ In this exercise, we want you to take a list of names stored in an array and put
 
 Specifically, we want you to:
 
-- Write a loop that will iterate from 0 to the length of the `people` array. You'll need to start with an initializer of  `let i = 0;`, but what condition do you need?
+- Write a loop that will iterate through the `people` array.
 - During each loop iteration, check if the current array item is equal to "Phil" or "Lola" using a conditional statement:
 
   - If it is, concatenate the array item to the end of the `refused` paragraph's `textContent`, followed by a comma and a space.
@@ -604,13 +733,15 @@ Specifically, we want you to:
 
 We've already provided you with:
 
-- `let i = 0;` — Your initializer.
 - `refused.textContent +=` — the beginnings of a line that will concatenate something on to the end of `refused.textContent`.
 - `admitted.textContent +=` — the beginnings of a line that will concatenate something on to the end of `admitted.textContent`.
 
-Extra bonus question — after completing the above tasks successfully, you will be left with two lists of names, separated by commas, but they will be untidy — there will be a comma at the end of each one. Can you work out how to write lines that slice the last comma off in each case, and add a full stop to the end? Have a look at the [Useful string methods](/en-US/docs/Learn/JavaScript/First_steps/Useful_string_methods) article for help.
+Extra bonus question — after completing the above tasks successfully, you will be left with two lists of names, separated by commas, but they will be untidy — there will be a comma at the end of each one.
+Can you work out how to write lines that slice the last comma off in each case, and add a full stop to the end?
+Have a look at the [Useful string methods](/en-US/docs/Learn/JavaScript/First_steps/Useful_string_methods) article for help.
 
-If you make a mistake, you can always reset the example with the "Reset" button. If you get really stuck, press "Show solution" to see a solution.
+If you make a mistake, you can always reset the example with the "Reset" button.
+If you get really stuck, press "Show solution" to see a solution.
 
 ```html hidden
 <h2>Live output</h2>
@@ -629,7 +760,7 @@ const refused = document.querySelector('.refused');
 admitted.textContent = 'Admit: ';
 refused.textContent = 'Refuse: '
 
-// let i = 0;
+// loop starts here
 
 // refused.textContent += ;
 // admitted.textContent += ;
@@ -694,7 +825,26 @@ solution.addEventListener('click', function() {
   updateCode();
 });
 
-const jsSolution = 'const people = [\'Chris\', \'Anne\', \'Colin\', \'Terri\', \'Phil\', \'Lola\', \'Sam\', \'Kay\', \'Bruce\'];\n\nconst admitted = document.querySelector(\'.admitted\');\nconst refused = document.querySelector(\'.refused\');\n\nadmitted.textContent = \'Admit: \';\nrefused.textContent = \'Refuse: \'\nlet i = 0;\n\ndo {\n if(people[i] === \'Phil\' || people[i] === \'Lola\') {\n refused.textContent += people[i] + \', \';\n } else {\n admitted.textContent += people[i] + \', \';\n }\n i++;\n} while(i < people.length);\n\nrefused.textContent = refused.textContent.slice(0,refused.textContent.length-2) + \'.\';\nadmitted.textContent = admitted.textContent.slice(0,admitted.textContent.length-2) + \'.\';';
+const jsSolution = `
+const people = ['Chris', 'Anne', 'Colin', 'Terri', 'Phil', 'Lola', 'Sam', 'Kay', 'Bruce'];
+
+const admitted = document.querySelector('.admitted');
+const refused = document.querySelector('.refused');
+
+admitted.textContent = 'Admit: ';
+refused.textContent = 'Refuse: ';
+
+for (const person of people) {
+  if (person === 'Phil' || person === 'Lola') {
+    refused.textContent += \`\${person}, \`;
+  } else {
+    admitted.textContent += \`\${person}, \`;
+  }
+}
+
+refused.textContent = refused.textContent.slice(0,refused.textContent.length-2) + '.';
+admitted.textContent = admitted.textContent.slice(0,admitted.textContent.length-2) + '.';`;
+
 let solutionEntry = jsSolution;
 
 textarea.addEventListener('input', updateCode);
@@ -747,33 +897,52 @@ textarea.onkeyup = function(){
 
 ## Which loop type should you use?
 
-For basic uses, `for`, `while`, and `do...while` loops are largely interchangeable. They can all be used to solve the same problems, and which one you use will largely depend on your personal preference — which one you find easiest to remember or most intuitive. Let's have a look at them again.
+If you're iterating through an array or some other object that supports it, and don't need access to the index position of each item, then `for...of` is the best choice. It's easier to read and there's less to go wrong.
 
-First `for`:
+For other uses, `for`, `while`, and `do...while` loops are largely interchangeable.
+They can all be used to solve the same problems, and which one you use will largely depend on your personal preference — which one you find easiest to remember or most intuitive.
+We would recommend `for`, at least to begin with, as it is probably the easiest for remembering everything — the initializer, condition, and final-expression all have to go neatly into the parentheses, so it is easy to see where they are and check that you aren't missing them.
 
-    for (initializer; condition; final-expression) {
-      // code to run
-    }
+Let's have a look at them all again.
+
+First `for...of`:
+
+```
+for (const item of array) {
+  // code to run
+}
+```
+
+
+`for`:
+
+```
+for (initializer; condition; final-expression) {
+  // code to run
+}
+```
 
 `while`:
 
-    initializer
-    while (condition) {
-      // code to run
+```
+initializer
+while (condition) {
+  // code to run
 
-      final-expression
-    }
+  final-expression
+}
+```
 
 and finally `do...while`:
 
-    initializer
-    do {
-      // code to run
-
-      final-expression
-    } while (condition)
+```
+initializer
+do {
+  // code to run
 
-We would recommend `for`, at least to begin with, as it is probably the easiest for remembering everything — the initializer, condition, and final-expression all have to go neatly into the parentheses, so it is easy to see where they are and check that you aren't missing them.
+  final-expression
+} while (condition)
+```
 
 > **Note:** There are other loop types/features too, which are useful in advanced/specialized situations and beyond the scope of this article. If you want to go further with your loop learning, read our advanced [Loops and iteration guide](/en-US/docs/Web/JavaScript/Guide/Loops_and_iteration).
 
@@ -783,17 +952,18 @@ You've reached the end of this article, but can you remember the most important
 
 ## Conclusion
 
-This article has revealed to you the basic concepts behind, and different options available when looping code in JavaScript. You should now be clear on why loops are a good mechanism for dealing with repetitive code and are raring to use them in your own examples!
+This article has revealed to you the basic concepts behind, and different options available when looping code in JavaScript.
+You should now be clear on why loops are a good mechanism for dealing with repetitive code and are raring to use them in your own examples!
 
 If there is anything you didn't understand, feel free to read through the article again, or [contact us](/en-US/docs/Learn#contact_us) to ask for help.
 
 ## See also
 
 - [Loops and iteration in detail](/en-US/docs/Web/JavaScript/Guide/Loops_and_iteration)
+- [for...of reference](/en-US/docs/Web/JavaScript/Reference/Statements/for...of)
 - [for statement reference](/en-US/docs/Web/JavaScript/Reference/Statements/for)
 - [while](/en-US/docs/Web/JavaScript/Reference/Statements/while) and [do...while](/en-US/docs/Web/JavaScript/Reference/Statements/do...while) references
 - [break](/en-US/docs/Web/JavaScript/Reference/Statements/break) and [continue](/en-US/docs/Web/JavaScript/Reference/Statements/continue) references
-- [What’s the Best Way to Write a JavaScript For Loop?](https://www.impressivewebs.com/javascript-for-loop/) — some advanced loop best practices
 
 {{PreviousMenuNext("Learn/JavaScript/Building_blocks/conditionals","Learn/JavaScript/Building_blocks/Functions", "Learn/JavaScript/Building_blocks")}}
 
diff --git a/files/en-us/learn/javascript/building_blocks/looping_code/loop_js-02-farm.png b/files/en-us/learn/javascript/building_blocks/looping_code/loop_js-02-farm.png
deleted file mode 100644
index 0b22b9349091fdcda8a5c26becbea6747e148ea0..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 41232
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
V>k5<gt^3cBtdyc;4b&*;e*mEu=4=1}

diff --git a/files/en-us/learn/javascript/building_blocks/test_your_skills_colon__loops/index.md b/files/en-us/learn/javascript/building_blocks/test_your_skills_colon__loops/index.md
index 6f6423c06166691..60fd6cd067134c7 100644
--- a/files/en-us/learn/javascript/building_blocks/test_your_skills_colon__loops/index.md
+++ b/files/en-us/learn/javascript/building_blocks/test_your_skills_colon__loops/index.md
@@ -37,9 +37,9 @@ If you haven't read about objects yet, don't worry! For now, all you need to kno
 
 You are given three variables to begin with:
 
-- `i` — starts off with a value of 0; intended to be used as an iterator.
 - `name` — contains a name to search for
-- `para` — contains a reference to a paragraph, which will be used to report the results.
+- `para` — contains a reference to a paragraph, which will be used to report the results
+- `phonebook` - contains the phonebook entries to search.
 
 You should use a type of loop that you've not used in the previous task.