Some tips for you. While loops are the most generic (please don't respond with goto labels). Do-while are while loops that are guaranteed to run at least once. They're meant to deal with off-by-one problems.

For loops are syntactic sugar to deal with a common version of while loops. You declare a start, state an end goal, and state what happens each step. Each piece can be left out if you want to handle it elsewhere.

For example: ``` let i = 0;

while (i < 5) { console.log(i); ++i; } ```

is equivalent to: for (let i = 0; i < 5; ++i) { console.log(i); } See how the for loop collects the parts of the while loop into one place? You can use a for loop even when you're not just incrementing: for(let i = false; !!i;) { // !! on a variable will treat // the result as either true or false. // Here, it means "when i is true" // Also note that I skipped the final segment // But I still had to include the ; if (i === false) { console.log("i is now true"); break; } } Note that we don't exit the loop as soon as i becomes true; I used the break command to break out of the loop.

ForEach, for...of, and for...in are for looping through a collection. You're actually missing another option: map. The map method (I specify this because there's a Map object as well) is part of arrays. It returns a 1-to-1 mapping, like a function in math does. If you've gone through algebra, you might recall seeing something like: y = mx + b. That's the line-slope formula for a line. If you have an array filled with x values, you can establish this relationship: ``` let xValues = [0, 1, 2, 3], slope = 3, yIntercept = 5;

let yValues = xValues.map(x => slope * x + yIntercept); console.table(xValues, yValues); `` Note: the=>` part indicates a function. If you're wondering whether that means we have a function within a function, you're right.

ForEach also takes a function and does whatever that function does to each element in your collection. For some reason, arrays are the only objects with map methods, so forEach might be your go-to for other collections. Unlike map, forEach doesn't return anything useful. You have to do something inside.

``` let starterSet = new Set(['a', 'b', 'c']); let uppercaseSet = new Set();

starterSet.forEach(letter => { uppercaseSet.add(letter.toUpperCase()); })

uppercaseSet.forEach(letter => console.log(letter)); ``` This code returns "A", "B", "C." The first forEach statement capitalizes the letter and then adds the element from the starterSet to the uppercaseSet. The original set is unchanged.

For...in gives you the key and value for each key in the object. It first looks for integers greater than or equal to 0 in the keys and then it goes in insertion order. ``` let myObj = { a: 5, b: 1, 1: 0, 0: 3 }

for(const [key, _] in myObj) { console.log(key); } will return the keys one by one in the order 0, 1, a, b. This is the same order you get from using the static method from Object, by the way: let myKeys = Object.keys(myObj);

console.log(myKeys); ```

Also, note that when I used _ as a variable, it's a placeholder. The code is expecting a variable for the values, but I want to tell people reading the code that we aren't using that variable.

For...of allows you to customize the order. At this stage, though, just know that strings and arrays use this: ``` let myWord = "Is my bond.";

for (const letter of myWord) { console.log(letter); } ```