Full Programs: Converting on Purpose

New here: converting each token with Number() yourself. The starter's nextInt() is exactly Number(next()); here you see both halves. The program reads two numbers and an operator, all three as text.

const input = require("fs").readFileSync(0, "utf8");
const tokens = input.split(/\s+/).filter(Boolean);
let at = 0;
const next = () => tokens[at++];
const nextInt = () => Number(next());
const out = [];

const left = next();
const op = next();
const right = next();

const a = Number(left);
const b = Number(right);
const result = op === "+" ? a + b : a * b;

out.push("text joined: " + (left + right));
out.push("converted:   " + a + " " + op + " " + b + " = " + result);

console.log(out.join("\n"));

text joined: 75
converted:   7 + 5 = 12

That output is for the input 7 + 5. The first line is Bob's old bug, kept on purpose: two strings joined. The second converts first and adds numbers. The ternary handles + and *; Exercise 2 adds - and /.

New here: Number.isNaN() as the test, on a value you converted yourself.

const input = require("fs").readFileSync(0, "utf8");
const tokens = input.split(/\s+/).filter(Boolean);
let at = 0;
const next = () => tokens[at++];
const nextInt = () => Number(next());
const out = [];

const n = nextInt();
for (let i = 0; i < n; i++) {
  const text = next();
  const value = Number(text);
  out.push(text + ": " + (Number.isNaN(value) ? "not a number" : "the number " + value));
}

console.log(out.join("\n"));

12: the number 12
-4.5: the number -4.5
abc: not a number
1e3: the number 1000
0x1f: the number 31
12px: not a number
Infinity: the number Infinity

That output is for the input 7, then 12 -4.5 abc 1e3 0x1f 12px Infinity. 1e3 is 1 times 10 to the power 3, and 0x1f is hexadecimal for 31; Number() reads both. The last line is a gap: Infinity passes as a number. Exercise 1 closes it.

New here: parseInt with and without its radix, and parseFloat, side by side with Number().

const input = require("fs").readFileSync(0, "utf8");
const tokens = input.split(/\s+/).filter(Boolean);
let at = 0;
const next = () => tokens[at++];
const nextInt = () => Number(next());
const out = [];

const n = nextInt();
for (let i = 0; i < n; i++) {
  const text = next();
  out.push(text + ": Number " + Number(text) + ", parseInt " + parseInt(text) + ", base 10 " + parseInt(text, 10) + ", parseFloat " + parseFloat(text));
}

console.log(out.join("\n"));

12px: Number NaN, parseInt 12, base 10 12, parseFloat 12
3.5kg: Number NaN, parseInt 3, base 10 3, parseFloat 3.5
08: Number 8, parseInt 8, base 10 8, parseFloat 8
0x1f: Number 31, parseInt 31, base 10 0, parseFloat 0
1e3: Number 1000, parseInt 1, base 10 1, parseFloat 1000
abc: Number NaN, parseInt NaN, base 10 NaN, parseFloat NaN

That output is for the input 6, then 12px 3.5kg 08 0x1f 1e3 abc. Read it row by row. parseInt stops at the point in 3.5kg and at the e in 1e3, because neither is a digit. parseFloat reads both, but it never reads hexadecimal. A prefix reader stops early without any warning.

New here: toFixed, its string, and its rounding of the stored value.

const input = require("fs").readFileSync(0, "utf8");
const tokens = input.split(/\s+/).filter(Boolean);
let at = 0;
const next = () => tokens[at++];
const nextInt = () => Number(next());
const out = [];

const bill = Number(next());
const percent = Number(next());

const tip = bill * percent / 100;
const tipText = tip.toFixed(2);

out.push("tip:   " + tipText);
out.push("total: " + (bill + tip).toFixed(2));
out.push("typeof tipText: " + typeof tipText);
out.push("(1.005).toFixed(2): " + (1.005).toFixed(2));

console.log(out.join("\n"));

tip:   6.00
total: 46.00
typeof tipText: string
(1.005).toFixed(2): 1.00

That output is for the input 40 15, a bill of 40 and a 15 percent tip. The total adds two numbers, bill + tip, and only then calls toFixed. Arithmetic first, text last: that order is the rule, and lesson 04 shows a bill where breaking it costs a cent.

New here: filter(Boolean), which the starter has used since Module 1. Lesson 01 named the falsy values: false, 0, "", null, undefined and NaN, plus -0 and 0n as two more forms of zero. This program prints every one, then five values that only look empty. check is a one-line arrow function, the same shape as the starter's next.

const out = [];
const check = (label, value) => out.push(label + ": " + (Boolean(value) ? "truthy" : "falsy"));

check("false", false);
check("0", 0);
check("-0", -0);
check("0n", 0n);
check("empty string", "");
check("null", null);
check("undefined", undefined);
check("NaN", NaN);
check("the text 0", "0");
check("the text false", "false");
check("one space", " ");
check("empty array", []);
check("empty object", {});

const mixed = [0, "0", "", " ", null, "12", NaN, []];
const kept = mixed.filter(Boolean);
out.push("kept " + kept.length + " of " + mixed.length);

console.log(out.join("\n"));
console.log(kept);

false: falsy
0: falsy
-0: falsy
0n: falsy
empty string: falsy
null: falsy
undefined: falsy
NaN: falsy
the text 0: truthy
the text false: truthy
one space: truthy
empty array: truthy
empty object: truthy
kept 4 of 8
[ '0', ' ', '12', [] ]

A string is falsy only when it is empty, so "0" and "false" are truthy. An array or an object is truthy even when empty. The last line is Node's display of an array, with strings in single quotes. So the starter's filter(Boolean) drops the empty strings at the edges of the input and keeps a token "0".

New here: one number formatted three ways, with Intl.NumberFormat. Zara's delivery app logs trips in metres. Her report shows kilometres in English and in Bangla, the miles, and a fuel cost in US dollars.

const input = require("fs").readFileSync(0, "utf8");
const tokens = input.split(/\s+/).filter(Boolean);
let at = 0;
const next = () => tokens[at++];
const nextInt = () => Number(next());
const out = [];

const n = nextInt();
const en = new Intl.NumberFormat("en-US");
const bn = new Intl.NumberFormat("bn-BD");
const usd = new Intl.NumberFormat("en-US", { style: "currency", currency: "USD" });

let totalKm = 0;
for (let i = 0; i < n; i++) {
  const metres = Number(next());
  const km = metres / 1000;
  totalKm += km;
  out.push(en.format(km) + " km | " + bn.format(km) + " km | " + en.format(km * 0.621371) + " mi");
}
out.push("total: " + en.format(totalKm) + " km");
out.push("fuel at $0.12 a km: " + usd.format(totalKm * 0.12));

console.log(out.join("\n"));

2.5 km | ২.৫ km | 1.553 mi
42.195 km | ৪২.১৯৫ km | 26.219 mi
1,234,567.891 km | ১২,৩৪,৫৬৭.৮৯১ km | 767,124.685 mi
total: 1,234,612.586 km
fuel at $0.12 a km: $148,153.51

That output is for the input 3, then 2500 42195 1234567891; the last trip is a truck's lifetime odometer. The same number reads 1,234,567.891 in en-US and ১২,৩৪,৫৬৭.৮৯১ in bn-BD, grouped in lakhs. The currency formatter adds the dollar sign and rounds to cents. Every format call returns a string, so formatting is the last step.