When to Use Which: Methods or a Loop, a Template or +, and When It Is a Regex

The program reads one record and prints its fields one per line, with split's count beside the loop's.

const input = require("fs").readFileSync(0, "utf8");
const lines = input.split("\n");
let at = 0;
const next = () => lines[at++];
const nextInt = () => Number(next());
const out = [];

const record = next();
const fields = [];
let field = "";
let inQuotes = false;
for (const ch of record) {
  if (ch === "\"") {
    inQuotes = !inQuotes;
  } else if (ch === "," && !inQuotes) {
    fields.push(field);
    field = "";
  } else {
    field += ch;
  }
}
fields.push(field);

out.push(`split(","): ${record.split(",").length} pieces`);
out.push(`the loop:   ${fields.length} fields`);
for (let i = 0; i < fields.length; i++) {
  out.push(`${i + 1}: ${fields[i]}`);
}

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

split(","): 4 pieces
the loop:   3 fields
1: Kenji
2: 12, Lake Road
3: Dhaka

That output is for the input Kenji,"12, Lake Road",Dhaka. The comma inside the quotes stayed in the address, and the quote marks themselves were dropped. The last push after the loop saves the final field, which no comma ends.

One honest gap remains. RFC 4180 writes a quote inside a quoted field as two quotes, "". This loop flips the flag twice and loses both, so "She said ""hi""" comes out as She said hi. Exercise 3 asks you to keep it.

Each line prints the three answers for one row, in brackets, so an empty string still shows.

const s = "template";
console.log(`(1, 4):  [${s.slice(1, 4)}] [${s.substring(1, 4)}] [${s.substr(1, 4)}]`);
console.log(`(4, 1):  [${s.slice(4, 1)}] [${s.substring(4, 1)}] [${s.substr(4, 1)}]`);
console.log(`(-3):    [${s.slice(-3)}] [${s.substring(-3)}] [${s.substr(-3)}]`);
console.log(`(2, -1): [${s.slice(2, -1)}] [${s.substring(2, -1)}] [${s.substr(2, -1)}]`);
console.log(`(-4, 2): [${s.slice(-4, 2)}] [${s.substring(-4, 2)}] [${s.substr(-4, 2)}]`);
console.log(`(3):     [${s.slice(3)}] [${s.substring(3)}] [${s.substr(3)}]`);

(1, 4):  [emp] [emp] [empl]
(4, 1):  [] [emp] [l]
(-3):    [ate] [template] [ate]
(2, -1): [mplat] [te] []
(-4, 2): [] [te] [la]
(3):     [plate] [plate] [plate]

Row (4, 1) is Bob's off-by-one waiting to happen. slice says "nothing there" and the empty result shows up in a test. substring quietly swaps the two numbers, and the wrong piece looks fine. So write slice: negatives count from the end, the end is excluded, and nothing is swapped behind your back.

Is there an @? Where is it? And what is the name in front of it?

const email = "kenji@mail.com";
console.log(email.includes("@"));
console.log(email.indexOf("@"));
console.log(email.slice(0, email.indexOf("@")));
console.log(email.includes("#"), email.indexOf("#"));

true
5
kenji
false -1

For "is it there", includes reads like the question and cannot fall into lesson 02's trap, where if (s.indexOf(x)) treats a match at index 0 as false. When you need the position, as for the name, indexOf is the tool, and you compare its answer with -1.

The same sentence with + and as a template, then a short label, then a CSV row from an array.

const name = "Amara";
const books = 3;
const total = 1940;
console.log("Dear " + name + ", your " + books + " books cost Tk " + total + ".");
console.log(`Dear ${name}, your ${books} books cost Tk ${total}.`);
console.log("Tk " + total);
const row = ["Amara", "16", "Dhaka", "amara@mail.com"];
console.log(row.join(","));

Dear Amara, your 3 books cost Tk 1940.
Dear Amara, your 3 books cost Tk 1940.
Tk 1940
Amara,16,Dhaka,amara@mail.com

The first two lines print the same text. In the + line, count the quote marks and the spaces you had to place by hand; one missing space and the receipt says 3books. For two pieces, "Tk " + total is short and clear. For a list, join puts exactly one separator between items and none at the ends.

Many teams make the template a rule. ESLint's prefer-template rule flags + between text and a value, and it can rewrite the line for you. That is a style choice that a team agrees on, not a speed rule: both lines produce the same string.

Members typed their own names, some with a capital and one with an accent. The default sort() compares as text in code order. The arrow function inside sort is the short form Module 5 explains.

const names = ["zara", "Amara", "Émile", "bob", "Kenji"];
names.sort();
console.log(`< order:        ${names.join(", ")}`);
names.sort((x, y) => x.localeCompare(y));
console.log(`localeCompare:  ${names.join(", ")}`);
const collator = new Intl.Collator("en");
names.sort(collator.compare);
console.log(`Intl.Collator:  ${names.join(", ")}`);
const photos = ["photo10.jpg", "photo9.jpg", "photo2.jpg"];
photos.sort(new Intl.Collator("en", { numeric: true }).compare);
console.log(`numeric: true:  ${photos.join(", ")}`);

< order:        Amara, Kenji, bob, zara, Émile
localeCompare:  Amara, bob, Émile, Kenji, zara
Intl.Collator:  Amara, bob, Émile, Kenji, zara
numeric: true:  photo2.jpg, photo9.jpg, photo10.jpg

In code order, bob waits behind Kenji, and Émile lands last, because É is code 201. localeCompare and the collator give the order a reader expects. The option numeric: true compares runs of digits as numbers, so photo10 comes after photo9. For Bangla names, new Intl.Collator("bn") uses the Bangla rules.

JSON.stringify prints each piece in quotes and writes a lone half of an emoji as an escape such as \ud83d. Printed directly, a lone half shows as a replacement character instead.

const name = "Zara 😀";
console.log(name.length);
console.log(JSON.stringify(name.split("")));
console.log(JSON.stringify([...name]));
console.log(JSON.stringify(Array.from(name)));
console.log(JSON.stringify(name.split("").reverse().join("")));
console.log([...name].reverse().join(""));

7
["Z","a","r","a"," ","\ud83d","\ude00"]
["Z","a","r","a"," ","😀"]
["Z","a","r","a"," ","😀"]
"\ude00\ud83d araZ"
😀 araZ

split("") gave seven pieces, the last two half an emoji each, and reversing put the halves in the wrong order. [...name] gave six pieces and a clean reverse. For text that is ASCII by its rules, such as the judge's words, split("") is fine. For anything a person typed, use [...s]. Bangla vowel signs still split from their letters, and that is lesson 05's Intl.Segmenter.