The language all 5 written

example.mjs

1
2
3
4
5
6
7
8
9const city = "Lagos";
let visitors = 120;

console.log(city, visitors);

visitors = visitors + 30;      // let: the name can be pointed at a new value
console.log(city, visitors);

check("visitors went up by 30", visitors, 150);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14console.log(typeof 42);            // a number
console.log(typeof "hello");       // a string of text
console.log(typeof true);          // a boolean: true or false
console.log(typeof undefined);     // "no value was ever put here"
console.log(typeof null);          // "deliberately empty" -- see below
console.log(typeof 10n);           // a BigInt: a whole number of any size
console.log(typeof Symbol("id"));  // a unique identifier
console.log(typeof { a: 1 });      // an object: everything else
console.log(typeof [1, 2]);        // arrays are objects too
console.log(typeof function () {}); // and so are functions, with a special answer

check("a number", typeof 42, "number");
check("an array is an object", typeof [], "object");
check("and so, confusingly, is null", typeof null, "object");

example.mjs

1
2
3
4
5
6
7let answer = 42;
console.log(typeof answer, answer);

answer = "forty-two";
console.log(typeof answer, answer);

check("the same name now holds a string", typeof answer, "string");

example.mjs

1
2
3
4
5
6const basket = ["apples"];
basket.push("pears");        // changing the array itself: allowed

console.log(basket);

check("a const array can still grow", basket.length, 2);

example.mjs

1
2
3
4
5
6
7
8
9
10let notYet;
const person = { name: "Ada", middleName: null };   // null: known to be empty

console.log(notYet);             // declared, never assigned
console.log(person.email);       // a property that does not exist
console.log(person.middleName);  // a property someone set to null on purpose

check("an unset let is undefined", notYet, undefined);
check("a missing property is undefined", person.email, undefined);
check("null had to be written by someone", person.middleName, null);

example.mjs

1
2
3
4
5
6
7
8
9const maxRetries = 3;                  // camelCase: a normal variable
const DEFAULT_TIMEOUT_MS = 5_000;      // a fixed setting; _ in a number is only for reading
const $price = 9.99;                   // legal, but unusual
const cafe = "café", café = "also fine";

console.log(maxRetries, DEFAULT_TIMEOUT_MS, $price, cafe, café);

check("the underscore does not change the number", DEFAULT_TIMEOUT_MS, 5000);
check("two names that differ by an accent are two names", cafe === café, false);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13console.log(7 + 2, 7 - 2, 7 * 2, 7 / 2);   // division is never whole-number division
console.log(7 % 2);                         // remainder
console.log(2 ** 10);                       // power
console.log(Math.trunc(7 / 2));             // whole-number part, if you want it

let score = 10;
score += 5;      // the same as score = score + 5
score *= 2;
score++;         // add one
console.log(score);

check("7 / 2 is not 3", 7 / 2, 3.5);
check("the running score", score, 31);

example.mjs

1
2
3
4
5console.log(0.1 + 0.2);
console.log(0.1 + 0.2 === 0.3);
console.log((0.1).toFixed(20), "<- what 0.1 is really stored as");

check("0.1 + 0.2 is not 0.3", 0.1 + 0.2 === 0.3, false);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13// Never compare computed fractions with ===. Compare with a tolerance.
const close = (a, b) => Math.abs(a - b) < 1e-9;

console.log(close(0.1 + 0.2, 0.3));

// The error grows as you keep adding.
let total = 0;
for (let i = 0; i < 10; i++) total += 0.1;
console.log(total);

check("equal within a tolerance", close(0.1 + 0.2, 0.3), true);
check("ten tenths are not quite one", total === 1, false);
check("but they are close to it", close(total, 1), true);

example.mjs

1
2
3
4
5
6
7
8const inPounds = 1.10 + 2.20;       // a £1.10 item and a £2.20 item
const inPence = 110 + 220;          // the same basket, in whole pence

console.log(inPounds);
console.log(inPence / 100);

check("adding the fractions is already wrong", inPounds === 3.3, false);
check("adding whole pence is exact", inPence, 330);

example.mjs

1
2
3
4
5
6
7
8
9
10console.log((0.1 + 0.2).toFixed(2));    // a string, rounded to 2 places
console.log((2.5).toFixed(0));
console.log((1.005).toFixed(2), "<- not 1.01");
console.log((1.005).toFixed(20), "<- because this is what 1.005 is");

console.log(Math.round(2.5), Math.round(-2.5));   // .5 goes up, towards +Infinity

check("toFixed returns a string", typeof (1.5).toFixed(1), "string");
check("1.005 rounds down, because it is slightly less than 1.005", (1.005).toFixed(2), "1.00");
check("Math.round(-2.5) goes up, to -2", Math.round(-2.5), -2);

example.mjs

1
2
3
4
5
6
7
8
9
10const gbp = new Intl.NumberFormat("en-GB", { style: "currency", currency: "GBP" });
const ngn = new Intl.NumberFormat("en-NG", { style: "currency", currency: "NGN" });
const german = new Intl.NumberFormat("de-DE");

console.log(gbp.format(1234.5));
console.log(ngn.format(1234.5));
console.log(german.format(1234567.891));

check("pounds, with a separator and two places", gbp.format(1234.5), "£1,234.50");
check("German uses . for thousands and , for decimals", german.format(1234567.891), "1.234.567,891");

example.mjs

1
2
3
4
5
6
7console.log(Number("42"), Number(" 42 "), Number("42px"), Number(""));
console.log(parseInt("42px"), parseInt("px42"), parseFloat("3.14abc"));
console.log(Number(null), Number(undefined), Number(true));

check("Number is strict: any junk gives NaN", Number("42px"), NaN);
check("parseInt reads digits until it cannot", parseInt("42px"), 42);
check("an empty string becomes 0, not NaN", Number(""), 0);

example.mjs

1
2
3
4
5
6
7
8
9console.log(0 / 0, 1 / 0, -1 / 0);
console.log(typeof NaN);                  // NaN is a number that means "not a number"
console.log(NaN === NaN);                 // the only value not equal to itself
console.log(Number.isNaN(NaN), Number.isNaN("hello"));
console.log(isNaN("hello"), "<- the old global isNaN converts first");

check("NaN is not equal to itself", NaN === NaN, false);
check("Number.isNaN only says yes for NaN itself", Number.isNaN("hello"), false);
check("dividing by zero is Infinity, not an error", 1 / 0, Infinity);

example.mjs

1
2
3
4
5
6
7const big = Number.MAX_SAFE_INTEGER;
console.log(big);                 // 2 ** 53 - 1
console.log(big + 1);
console.log(big + 2, "<- should end in 3");

check("past the limit, adding 1 can do nothing", 2 ** 53 + 1 === 2 ** 53, true);
check("Number.isSafeInteger knows where the edge is", Number.isSafeInteger(big + 1), false);

example.mjs

1
2
3
4
5
6
7
8
9const sent = "9007199254740993";
const response = `{"orderId": ${sent}}`;
const order = JSON.parse(response);

console.log("sent:    ", sent);
console.log("received:", order.orderId);

check("JSON.parse silently changed the id", String(order.orderId) === sent, false);
check("into its nearest neighbour that fits", String(order.orderId), "9007199254740992");

example.mjs

1
2
3
4
5
6
7const exact = 9007199254740993n;          // the n makes it a BigInt
console.log(exact, exact + 2n);
console.log(2n ** 100n);
console.log(10n / 3n, "<- BigInt division drops the remainder");

check("BigInt keeps every digit", (exact + 2n).toString(), "9007199254740995");
check("and can go far past 2**53", (2n ** 100n).toString().length, 31);

example.mjs

1
2
3
4
5
6
7
8
9
10const single = 'single quotes';
const double = "double quotes";
const backtick = `backticks, which can hold ${1 + 1} expressions`;

console.log(single);
console.log(double);
console.log(backtick);
console.log("it's easy to include the other kind", 'she said "hi"');

check("backticks run the code inside ${}", backtick.includes("hold 2 expressions"), true);

example.mjs

1
2
3
4
5
6
7
8
9const user = { name: "Ada", unread: 3 };

const message = `Hello ${user.name},
you have ${user.unread} new message${user.unread === 1 ? "" : "s"}.`;

console.log(message);

check("the plural was worked out inside the template", message.endsWith("3 new messages."), true);
check("and the line break is really in the string", message.split("\n").length, 2);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15const s = "  Hello, World  ";

console.log(JSON.stringify(s.trim()));          // strip spaces at both ends
console.log(s.trim().toUpperCase(), s.trim().toLowerCase());
console.log(s.includes("World"), s.startsWith("  He"), s.trim().endsWith("World"));
console.log(s.trim().indexOf("o"), s.trim().lastIndexOf("o"), s.indexOf("xyz"));
console.log(s.trim().replace("World", "Node"));
console.log("a-b-c".replaceAll("-", "+"));
console.log("a,b,,c".split(","));
console.log(["x", "y", "z"].join(" / "));
console.log("7".padStart(3, "0"), "ab".repeat(3));

check("indexOf gives -1 when it is not there", s.indexOf("xyz"), -1);
check("split keeps the empty piece between two commas", "a,b,,c".split(","), ["a", "b", "", "c"]);
check("padStart for fixed-width numbers", "7".padStart(3, "0"), "007");

example.mjs

1
2
3
4
5
6
7
8
9let word = "node";
word.toUpperCase();              // builds "NODE" -- and throws it away
console.log(word);

word = word.toUpperCase();       // keep the result by assigning it
console.log(word);

check("the original was never modified", "node".toUpperCase() === "node", false);
check("you have to keep what the method returns", word, "NODE");

example.mjs

1
2
3
4
5
6
7
8
9
10const path = "reports/2026/q3.csv";

console.log(path[0], path.at(-1));           // first character, last character
console.log(path.slice(0, 7));                // from 0 up to (not including) 7
console.log(path.slice(-6));                  // the last six characters
console.log(path.slice(path.lastIndexOf(".") + 1));   // everything after the last dot

check("at(-1) counts from the end", path.at(-1), "v");
check("slice with a negative number counts from the end", path.slice(-6), "q3.csv");
check("the file extension", path.slice(path.lastIndexOf(".") + 1), "csv");

example.mjs

1
2
3
4
5
6
7
8
9
10const fruit = ["banana", "apple", "Cherry"];

console.log("apple" < "banana", "Zebra" < "apple");
console.log([...fruit].sort());
console.log([...fruit].sort((a, b) => a.localeCompare(b)));

check("capitals sort before all lowercase letters", "Zebra" < "apple", true);
check("so a plain sort puts Cherry first", [...fruit].sort(), ["Cherry", "apple", "banana"]);
check("localeCompare sorts the way a person would",
      [...fruit].sort((a, b) => a.localeCompare(b)), ["apple", "banana", "Cherry"]);

example.mjs

1
2
3
4
5
6
7
8
9
10
11const plain = "hello";
const thumbs = "👍";
const accent = "é";

console.log(plain.length);
console.log(thumbs.length, "<- one emoji, length 2");
console.log([...thumbs].length, "<- spreading counts it once");

check("five letters, length 5", plain.length, 5);
check("an emoji is two UTF-16 units", thumbs.length, 2);
check("but one code point", [...thumbs].length, 1);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16const family = "👩‍👩‍👧";
const composed = "é";            // one code point
const decomposed = "e\u0301";    // e, plus a combining accent

console.log(family, family.length, [...family].length);
console.log(composed, decomposed, composed === decomposed);
console.log(composed.normalize() === decomposed.normalize());

const graphemes = [...new Intl.Segmenter("en", { granularity: "grapheme" }).segment(family)];
console.log("characters a person would count:", graphemes.length);

check("the family emoji is 8 UTF-16 units", family.length, 8);
check("and 5 code points, joined together", [...family].length, 5);
check("but one grapheme -- what a person sees", graphemes.length, 1);
check("two ways of writing é are different strings", composed === decomposed, false);
check("until you normalize them", composed.normalize() === decomposed.normalize(), true);

example.mjs

1
2
3
4
5
6
7console.log("line one\nline two");
console.log("a\ttab");
console.log("a backslash: \\");
console.log(String.raw`C:\new\temp`, "<- String.raw leaves backslashes alone");

check("\\n is one character, a newline", "\n".length, 1);
check("String.raw keeps the backslash", String.raw`\n`.length, 2);

example.mjs

1
2
3
4
5
6
7
8
9console.log(1 === 1, "1" === "1");
console.log(1 === "1");     // different types: never equal with ===
console.log(1 == "1");      // == converts first, then compares
console.log(0 == "", 0 == "0", "" == "0");
console.log(null == undefined, null === undefined);

check("=== never converts", 1 === "1", false);
check("== converts, so these are 'equal'", 0 == "", true);
check("but it is not even consistent with itself", "" == "0", false);

example.mjs

1
2
3
4
5
6
7
8
9console.log([] == false);
console.log([] == ![]);
console.log("5" + 3, "5" - 3);
console.log(true + true);
console.log([] + {});

check("an empty array is loosely equal to false", [] == false, true);
check("+ joins if either side is a string", "5" + 3, "53");
check("- always does arithmetic", "5" - 3, 2);

example.mjs

1
2
3
4
5
6
7
8
9
10const a = { id: 1 };
const b = { id: 1 };
const c = a;

console.log(a === b);     // two separate objects that happen to look alike
console.log(a === c);     // two names for the same object
console.log([1, 2] === [1, 2]);

check("equal-looking objects are not equal", a === b, false);
check("the same object is", a === c, true);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17// Each value, paired with how you would write it.
const falsy = [
  ["false", false], ["0", 0], ["-0", -0], ["0n", 0n],
  ['""', ""], ["null", null], ["undefined", undefined], ["NaN", NaN],
];
for (const [written, value] of falsy) {
  console.log(written.padEnd(9), "->", Boolean(value));
}

const surprising = ["0", "false", " ", [], {}];
console.log();
console.log("but all of these are truthy:");
for (const value of surprising) console.log(" ", JSON.stringify(value), "->", Boolean(value));

check("all eight are falsy", falsy.every(([, value]) => !value), true);
check("the string \"0\" is truthy", Boolean("0"), true);
check("so is an empty array", Boolean([]), true);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14function pageSize(requested) {
  return {
    withOr: requested || 20,          // any falsy value gets the default
    withNullish: requested ?? 20,     // only null or undefined gets the default
  };
}

console.log("not given: ", pageSize(undefined));
console.log("asked for 0:", pageSize(0));
console.log("asked for 5:", pageSize(5));

check("|| threw away a real 0", pageSize(0).withOr, 20);
check("?? kept it", pageSize(0).withNullish, 0);
check("both default when nothing was given", pageSize(undefined), { withOr: 20, withNullish: 20 });

example.mjs

1
2
3
4
5
6
7
8
9
10
11const orders = [
  { id: 7 },
  { id: 8, customer: { name: "Ada" } },
];

for (const order of orders) {
  console.log(order.id, order.customer?.name ?? "(guest)");
}

check("?. gives undefined instead of throwing", orders[0].customer?.name, undefined);
check("and pairs naturally with ??", orders[0].customer?.name ?? "(guest)", "(guest)");

example.mjs

1
2
3
4
5
6
7
8
9const profile = { name: "Ada", nickname: null, age: undefined };

console.log(JSON.stringify(profile));      // undefined disappears; null survives
console.log("age" in profile, profile.age);
console.log(null == undefined, null === undefined);
console.log(typeof null, typeof undefined);

check("JSON drops undefined properties", JSON.parse(JSON.stringify(profile)), { name: "Ada", nickname: null });
check("the property exists, holding undefined", "age" in profile, true);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14function grade(score) {
  if (score >= 70) {
    return "distinction";
  } else if (score >= 50) {
    return "pass";
  } else {
    return "not yet";
  }
}

console.log(grade(82), grade(55), grade(12));

check("the first true branch wins", grade(82), "distinction");
check("boundaries are inclusive with >=", grade(50), "pass");

example.mjs

1
2
3
4
5const items = 1;
const label = items === 1 ? "item" : "items";
console.log(`${items} ${label}`);

check("the ternary picked the singular", label, "item");

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18function shippingDays(method) {
  let days;
  switch (method) {
    case "express":
      days = 1;
    case "standard":        // no break above: express falls into here
      days = 5;
      break;
    default:
      days = 10;
  }
  return days;
}

console.log("express: ", shippingDays("express"), "<- should be 1");
console.log("standard:", shippingDays("standard"));

check("a missing break made express as slow as standard", shippingDays("express"), 5);

example.mjs

1
2
3
4
5
6
7const DAYS = { express: 1, standard: 5 };
const shippingDays = (method) => DAYS[method] ?? 10;

console.log(shippingDays("express"), shippingDays("standard"), shippingDays("pigeon"));

check("express is 1 day", shippingDays("express"), 1);
check("anything unknown gets the default", shippingDays("pigeon"), 10);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20// Counting: start; keep going while; step.
for (let i = 1; i <= 3; i++) {
  console.log("lap", i);
}

// Over the values in an array.
for (const colour of ["red", "green"]) {
  console.log("colour:", colour);
}

// While a condition holds.
let balance = 100;
let months = 0;
while (balance < 150) {
  balance *= 1.1;
  months++;
}
console.log(`${months} months to grow past 150`);

check("5 months at 10%", months, 5);

example.mjs

1
2
3
4
5
6
7
8
9
10
11
12const readings = [12, -1, 40, 999, 7];
const kept = [];

for (const r of readings) {
  if (r < 0) continue;      // skip this one, carry on with the next
  if (r > 100) break;       // stop the loop entirely
  kept.push(r);
}

console.log(kept);

check("continue skipped -1, break stopped at 999", kept, [12, 40]);

example.mjs

1
2
3
4
5
6
7
8const scores = [10, 20, 30];

for (const i in scores) {
  console.log(i, typeof i, "next index would be", i + 1);
}

check("for...in hands back the keys as strings", Object.keys(scores), ["0", "1", "2"]);
check("so i + 1 joins text", "0" + 1, "01");

example.mjs

1
2
3
4
5
6
7
8
9
10const stock = { apples: 12, pears: 0, plums: 7 };

for (const [fruit, count] of Object.entries(stock)) {
  console.log(fruit.padEnd(7), count);
}

const inStock = Object.entries(stock).filter(([, count]) => count > 0).map(([fruit]) => fruit);

check("entries gives [key, value] pairs", Object.entries(stock)[0], ["apples", 12]);
check("and pears are out of stock", inStock, ["apples", "plums"]);

example.mjs

1
2
3
4
5
6
7
8
9
10
11let attempts = 0;
let connected = false;

while (!connected) {
  attempts++;
  if (attempts === 3) connected = true;   // without this line, it runs forever
}

console.log("connected after", attempts, "attempts");

check("the loop ended because something inside changed the condition", attempts, 3);