02 Functions and collections: challenges

Keep display in the caller.

function welcome(name) {
  return `Welcome, ${name}!`;
}
console.log(welcome("Alex"));
console.log(welcome("Sam"));

The default applies when the fee argument is omitted.

function ticketCost(quantity, price, fee = 0) {
  return quantity * price + fee;
}
console.log(ticketCost(3, 6));
console.log(ticketCost(3, 6, 2));

Logging is an action; return supplies the call result.

function double(number) {
  return number * 2;
}
const result = double(4);
console.log(result);

Without the return, reaching the end returns undefined. Seeing a logged calculation is not evidence that the call returned it.

Second element means index 1.

const scores = [4, 7, 3];
scores[1] = 9;
scores.push(5);
console.log(scores.length);
console.log(scores[scores.length - 1]);

Use map and filter with callbacks that return.

const scores = [2, 5, 8];
const doubled = scores.map((score) => score * 2);
const selected = scores.filter((score) => score >= 5);
console.log(doubled.join(", "));
console.log(selected.join(", "));
console.log(scores.join(", "));

Copy before the mutating sort.

const scores = [3, 20, 8];
const sorted = scores.slice().sort((a, b) => a - b);
console.log(sorted.join(", "));
console.log(scores.join(", "));

Use brackets for a computed key.

const club = { id: 1, name: "Robotics", capacity: 12 };
const field = "capacity";
console.log(club[field]);
club.capacity = 14;
console.log(club.capacity);

find returns an element or undefined.

const clubs = [{ id: 1, name: "Robotics" }, { id: 2, name: "Art" }];
const found = clubs.find((club) => club.id === 99);
if (found === undefined) {
  console.log("No matching club");
} else {
  console.log(found.name);
}

A new binding is not necessarily a new object.

const original = { capacity: 12 };
const alias = original;
alias.capacity = 18;
console.log(original.capacity);

Both bindings refer to the same object. An outer spread copy is only shallow when there are nested objects.

Use a parameter and a returned result.

function sumScores(scores) {
  let total = 0;
  for (const score of scores) {
    total += score;
  }
  return total;
}
const result = sumScores([4, 7, 3]);
console.log(result);

Pause before the assignment and step over it.

function totalScores(scores) {
  let total = 0;
  for (const score of scores) {
    total += score;
  }
  return total;
}
const scores = [4, 7, 3];
const total = totalScores(scores);
console.log(`Total: ${total}`);

Before the second update, total is 4 and score is 7. The buggy update makes total 7; the repaired update makes it 11. Retest [] as 0 and [9] as 9.

Use an array of objects, a numeric-return function, filter, map, a loop and a checked find result.

const clubs = [
  { id: 1, name: "Robotics", capacity: 12, members: 10 },
  { id: 2, name: "Art", capacity: 8, members: 8 },
  { id: 3, name: "Coding", capacity: 16, members: 9 }
];

function placesLeft(club) {
  return club.capacity - club.members;
}

function availableClubs(records) {
  return records.filter((club) => placesLeft(club) > 0);
}

function totalAvailablePlaces(records) {
  let total = 0;
  for (const club of records) {
    total += placesLeft(club);
  }
  return total;
}

const available = availableClubs(clubs);
for (const club of available) {
  console.log(`${club.name}: ${placesLeft(club)} places left`);
}
console.log(`Available clubs: ${available.map((club) => club.name).join(", ")}`);
console.log(`Total places: ${totalAvailablePlaces(clubs)}`);

const chosen = clubs.find((club) => club.id === 2);
if (chosen !== undefined) {
  console.log(`${chosen.name}: ${placesLeft(chosen)} places left`);
}

Test an empty collection, all clubs full and one club exactly one member below capacity. These records assume non-negative integer counts with members no greater than capacity. Treat malformed or over-capacity external data as a separate validation problem; do not silently call it a valid availability calculation.