Flow Control

const temperature = 31

if (temperature > 35) {
  console.log("Heat warning")
} else if (temperature > 25) {
  console.log("Warm")
} else {
  console.log("Cold")
}

// Conditions are coerced to boolean — truthy/falsy from Module 01
const items = []
if (items.length) console.log("has items"); else console.log("empty")
if (items) console.log("but [] itself is truthy!")

// Braces are optional for one statement — but always use them
const score = 82
let grade
if (score >= 90) grade = "A"
else if (score >= 80) grade = "B"
else grade = "C"
console.log(grade)

// Ternary for a value, if for an action
const label = score >= 50 ? "pass" : "fail"
console.log(label)

// Guard clauses: return early instead of nesting
function describe(user) {
  if (!user) return "no user"
  if (!user.name) return "anonymous"
  return `user ${user.name}`
}
console.log(describe(null), describe({}), describe({ name: "Ada" }))

function dayType(day) {
  switch (day) {
    case "sat":
    case "sun":          // fall-through on purpose: two labels, one body
      return "weekend"
    case "fri":
      return "almost"
    default:
      return "weekday"
  }
}
console.log(dayType("sun"), dayType("fri"), dayType("tue"))

// The fall-through bug: no break
const n = 1
switch (n) {
  case 1:
    console.log("one")
  case 2:
    console.log("two")     // runs too!
    break
  case 3:
    console.log("three")
}

// An object lookup is often cleaner than a switch
const handlers = { start: () => "starting", stop: () => "stopping" }
const cmd = "stop"
console.log((handlers[cmd] ?? (() => "unknown"))())

// Counter loop
for (let i = 0; i < 3; i++) {
  console.log("i =", i)
}

// for…of — each item, no index
const fruits = ["apple", "banana", "cherry"]
for (const fruit of fruits) {
  console.log(fruit.toUpperCase())
}

// Need both? entries()
for (const [i, fruit] of fruits.entries()) {
  console.log(i, fruit)
}

// Strings, Maps and Sets are iterable too
for (const ch of "hi") console.log(ch)
for (const [k, v] of new Map([["a", 1], ["b", 2]])) console.log(k, v)

// Counting down, stepping by 2
for (let n = 10; n > 0; n -= 3) console.log(n)

// Accumulate
let total = 0
for (const price of [9.99, 4.5, 20]) total += price
console.log(total.toFixed(2))

// Collatz: unknown number of steps
let n = 27, steps = 0
while (n !== 1) {
  n = n % 2 === 0 ? n / 2 : 3 * n + 1
  steps++
}
console.log("steps:", steps)

// Retry with a cap — the shape of every polling loop
let attempt = 0, ok = false
while (!ok && attempt < 5) {
  attempt++
  ok = attempt === 3        // "succeeds" on the third try
  console.log(`attempt ${attempt}: ${ok ? "ok" : "retry"}`)
}

// do…while: body first, check after
let input
do {
  input = "y"               // imagine prompt("Continue?")
} while (input !== "y" && input !== "n")
console.log("got", input)

// Digits of a number, right to left
let num = 1234, digits = []
while (num > 0) {
  digits.push(num % 10)
  num = Math.floor(num / 10)
}
console.log(digits)

// break: leave the loop now
for (const n of [4, 8, 15, 16, 23, 42]) {
  if (n > 10) {
    console.log("first over 10:", n)
    break
  }
}

// continue: skip to the next iteration
for (let i = 1; i <= 6; i++) {
  if (i % 2 === 0) continue
  console.log("odd", i)
}

// Labelled break: leave an OUTER loop from an inner one
outer: for (let r = 0; r < 3; r++) {
  for (let c = 0; c < 3; c++) {
    if (r * c === 2) {
      console.log(`found at ${r},${c}`)
      break outer
    }
  }
}

// Often, a function with return is cleaner than break
function findFirstNegative(nums) {
  for (const n of nums) if (n < 0) return n
  return null
}
console.log(findFirstNegative([3, -1, -7]), findFirstNegative([1, 2]))

// …and array methods are cleaner still
console.log([4, 8, 15, 16].find(n => n > 10), [1, 2, 3, 4].filter(n => n % 2))

const user = { name: "Ada", age: 36, role: "admin" }

// for…in: property NAMES of an object
for (const key in user) console.log(key, "→", user[key])

// Usually clearer: Object.keys / values / entries + for…of
for (const [key, value] of Object.entries(user)) console.log(`${key}=${value}`)
console.log(Object.keys(user), Object.values(user))

// forEach: a method, takes a callback, no break
const letters = ["a", "b"]
letters.forEach((item, i) => console.log(i, item))

// The decision in one table — run to see it
console.table([
  { need: "each array item", use: "for…of" },
  { need: "index too", use: "for or entries()" },
  { need: "object keys", use: "Object.entries" },
  { need: "unknown count", use: "while" },
  { need: "new array from old", use: "map / filter (Module 04)" },
])