JavaScript: String, 1–40

1
2
3
4
5
6
7
8
9test('the plate is ten characters', size(plate), 10);
test('the empty string is zero', size(''), 0);
test('a single space is one', size(' '), 1);
test('spaces inside a sentence count too', size('a b c'), 5);
test('length is a number, not a function', typeof 'abc'.length, 'number');
test('a tab is one character even though it looks wider', size('\t'), 1);
test('the last valid index is length - 1', 'abc'['abc'.length - 1], 'c');
test('assigning to length throws in strict mode', refused, 'TypeError');
test('so the value never changes', 'abc'.length, 3);

1
2
3
4
5
6
7
8
9
10test('brackets give one character', first(word), 'L');
test('charAt gives the same', word.charAt(0), 'L');
test('the last character', last(word), 's');
test('past the end, brackets give undefined', word[99], undefined);
test('but charAt gives an EMPTY STRING', word.charAt(99), '');
test('a negative index with brackets is undefined', word[-1], undefined);
test('and charAt(-1) is empty too, not the last character', word.charAt(-1), '');
test('charAt with no argument reads index 0', word.charAt(), 'L');
test('what comes back is a string of length one', word[0].length, 1);
test('so there is no character type to compare against', typeof word[0], 'string');

1
2
3
4
5
6
7
8
9
10test('at(-1) is the last character', word.at(-1), 's');
test('at(-2) is the one before it', word.at(-2), 'o');
test('at(0) is the first', word.at(0), 'L');
test('positive indexes agree with brackets', word.at(3), word[3]);
test('too far back gives undefined', word.at(-99), undefined);
test('and so does too far forward', word.at(99), undefined);
test('it replaces the length arithmetic exactly', word.at(-1), word[word.length - 1]);
test('slice(-1) does the same job but returns a string', ''.slice(-1), '');
test('so on an empty string the two differ', ''.at(-1), undefined);
test('and at(-0) is the FIRST character, because -0 is 0', word.at(-0), 'L');

1
2
3
4
5
6
7
8
9
10
11test('A is 65', codeOf('A'), 65);
test('the gap between the cases is 32', codeOf('a') - codeOf('A'), 32);
test("the digit '0' is 48, not 0", codeOf('0'), 48);
test('fromCharCode builds a string from codes', String.fromCharCode(78, 71), 'NG');
test('charCodeAt past the end is NaN, so compare with Number.isNaN', Number.isNaN('A'.charCodeAt(9)), true);
test('for an emoji, charCodeAt sees only the first half', '👍'.charCodeAt(0), 55357);
test('codePointAt sees the whole thing', '👍'.codePointAt(0), 128077);
test('and fromCodePoint puts it back', String.fromCodePoint(128077), '👍');
test('fromCharCode cannot, because the number does not fit in 16 bits', String.fromCharCode(128077) === '👍', false);
test('though it can from both halves', String.fromCharCode(55357, 56397), '👍');
test('codePointAt(1) reads the SECOND half on its own', '👍'.codePointAt(1), 56397);

1
2
3
4
5
6
7
8
9
10test('the first four characters', text.slice(0, 4), 'Java');
test('from index 4 to the end', text.slice(4), 'Script');
test('the end index is excluded', text.slice(0, 1), 'J');
test('a negative start counts from the right', text.slice(-6), 'Script');
test('two negatives make a range', text.slice(-6, -3), 'Scr');
test('the last three characters', text.slice(-3), 'ipt');
test('no arguments copies the whole string', text.slice(), 'JavaScript');
test('a start past the end gives an empty string', text.slice(50), '');
test('an end before the start gives an empty string, not a reversed one', text.slice(4, 0), '');
test('slice never changes the original', text, 'JavaScript');

1
2
3
4
5
6
7
8
9
10test('they agree on ordinary arguments', text.slice(0, 4), text.substring(0, 4));
test('slice with the arguments reversed returns nothing', text.slice(4, 0), '');
test('substring silently SWAPS them instead', text.substring(4, 0), 'Java');
test('slice reads a negative index from the right', text.slice(-3), 'ipt');
test('substring clamps it to zero, so it returns everything', text.substring(-3), 'JavaScript');
test('two negatives collapse to an empty range in substring', text.substring(-6, -3), '');
test('while slice reads them as a real range', text.slice(-6, -3), 'Scr');
test('both clamp an end past the length', text.slice(4, 99), text.substring(4, 99));
test('and both agree with one non-negative argument', text.substring(2), text.slice(2));
test('neither touches the original', text, 'JavaScript');

1
2
3
4
5
6
7
8
9test('substr takes a LENGTH, not an end index', text.substr(4, 3), 'Scr');
test('the slice equivalent needs start + length', text.slice(4, 4 + 3), 'Scr');
test('so the two agree once you convert', byLegacy, bySlice);
test('with no length it runs to the end', text.substr(4), 'Script');
test('a negative start counts from the right, like slice', text.substr(-6, 3), 'Scr');
test('a zero length gives an empty string', text.substr(4, 0), '');
test('and so does a negative length', text.substr(4, -1), '');
test('substring with the same numbers means something else entirely', text.substring(4, 3), 'a');
test('it is still a real function, just a deprecated one', typeof text.substr, 'function');

1
2
3
4
5
6
7
8
9
10test('the first "the" is at index 0', line.indexOf('the'), 0);
test('the last one is at index 15', line.lastIndexOf('the'), 15);
test('a missing needle gives -1, not undefined', line.indexOf('dog'), -1);
test('a start position skips the first hit', line.indexOf('the', 1), 15);
test('lastIndexOf searches backwards from its start position', line.lastIndexOf('the', 14), 0);
test('the search is case sensitive', line.indexOf('The'), -1);
test('an empty needle is found at 0', line.indexOf(''), 0);
test('and at the length when searching backwards', 'abc'.lastIndexOf(''), 3);
test('so compare against -1 rather than testing truthiness', line.indexOf('cat') !== -1, true);
test('because index 0 is FALSY and would read as "not found"', Boolean(line.indexOf('the')), false);

1
2
3
4
5
6
7
8
9
10test('includes answers without any index arithmetic', file.includes('2025'), true);
test('and says no for something absent', file.includes('2024'), false);
test('startsWith checks the front', file.startsWith('invoice'), true);
test('endsWith checks the back', file.endsWith('.pdf'), true);
test('startsWith takes a position, so it can check mid-string', file.startsWith('2025', 8), true);
test('endsWith takes a length, treating the string as if it stopped there', file.endsWith('04', 15), true);
test('all three are case sensitive', file.endsWith('.PDF'), false);
test('an empty needle is always included', file.includes(''), true);
test('a regular expression is REFUSED, not stringified', withRegex, 'TypeError');
test('use search or test for a pattern instead', /2025/.test(file), true);

1
2
3
4
5
6
7
8
9
10test('search finds the first digit without knowing which digit', line.search(/[0-9]/), 6);
test('indexOf would have to be told the exact text', line.indexOf('42'), 6);
test('search returns -1 when nothing matches', line.search(/z/), -1);
test('a string argument becomes a regex, so a dot is a wildcard', 'abc'.search('.'), 0);
test('while indexOf treats the dot literally', 'abc'.indexOf('.'), -1);
test('search ignores the g flag and always reports the first match', line.search(/[0-9]+/g), 6);
test('case-insensitivity is a flag rather than a second method', line.search(/order/i), 0);
test('indexOf needs both sides lower-cased instead', line.toLowerCase().indexOf('order'), 0);
test('search takes NO start position, so a second argument is ignored', line.search(/[0-9]/, 10), 6);
test('skipping ahead means slicing first and adding the offset back', 10 + line.slice(10).search(/[0-9]/), 20);

1
2
3
4
5
6
7
8
9
10test('without g, match returns the first hit', one[0], '42');
test('and tells you where it was', one.index, 6);
test('with g, match returns every matched string', all, ['42', '2025', '04', '09']);
test('but drops the positions entirely', all.index, undefined);
test('no match gives null, not an empty array', line.match(/z+/g), null);
test('so default it before using the result', (line.match(/z+/g) || []).length, 0);
test('capture groups follow the whole match', 'a1'.match(/([a-z])([0-9])/).slice(0, 3), ['a1', 'a', '1']);
test('a named group lands in .groups', 'a1'.match(/(?<letter>[a-z])/).groups.letter, 'a');
test('the input string is carried along without g', one.input, line);
test('and the g result is an ordinary array', Array.isArray(all), true);

1
2
3
4
5
6
7
8
9
10test('every reading is found', readings.length, 3);
test('the first one is parsed properly', readings[0], { city: 'Lagos', temp: 21 });
test('and the last', readings[2], { city: 'Kano', temp: 38 });
test('matchAll keeps the index that match with g throws away', [...line.matchAll(READING)][0].index, 0);
test('the second match knows where it starts', [...line.matchAll(READING)][1].index, 11);
test('matchAll without the g flag throws', withoutG, 'TypeError');
test('the return value is an iterator, not an array', Array.isArray(line.matchAll(READING)), false);
test('so it has to be spread or looped', Array.isArray([...line.matchAll(READING)]), true);
test('no match gives an empty list rather than null', [...line.matchAll(/z+/g)], []);
test('the hottest city', readings.reduce((a, b) => (b.temp > a.temp ? b : a)).city, 'Kano');

1
2
3
4
5
6
7
8
9
10
11test('upper-casing is straightforward', shout('lagos'), 'LAGOS');
test('and so is lower-casing', 'LAGOS'.toLowerCase(), 'lagos');
test('digits and punctuation are untouched', shout('a-1-b'), 'A-1-B');
test('the German sharp s becomes TWO letters', 'ß'.toUpperCase(), 'SS');
test('so the string gets longer', 'ß'.toUpperCase().length, 2);
test('a whole word shows it', 'Straße'.toUpperCase(), 'STRASSE');
test('and the round trip does not come back', 'Straße'.toUpperCase().toLowerCase(), 'strasse');
test('which is not the original lower-cased', 'Straße'.toUpperCase().toLowerCase() === 'Straße'.toLowerCase(), false);
test('so never assume case conversion preserves length', 'Straße'.length !== 'Straße'.toUpperCase().length, true);
test('accents survive in both directions', 'ÉCOLE'.toLowerCase(), 'école');
test('and come back unchanged', 'école'.toUpperCase(), 'ÉCOLE');

1
2
3
4
5
6
7
8
9
10
11test('lower-casing both sides is the usual answer', sameText('Lagos', 'LAGOS'), true);
test('and it still rejects different words', sameText('Lagos', 'Kano'), false);
test('localeCompare returns 0 for equal strings', 'a'.localeCompare('a'), 0);
test('a negative number when the first sorts earlier', 'a'.localeCompare('b') < 0, true);
test('and a positive number the other way', 'b'.localeCompare('a') > 0, true);
test('sensitivity accent ignores case', sameIgnoringCase('Cafe', 'CAFE'), true);
test('but still counts an accent as a difference', sameIgnoringCase('cafe', 'café'), false);
test('sensitivity base ignores both', 'cafe'.localeCompare('café', 'en', { sensitivity: 'base' }), 0);
test('lower-casing does NOT ignore accents', sameText('cafe', 'café'), false);
test('and it disagrees with itself about the sharp s', sameText('STRASSE', 'straße'), false);
test('while the upper-case direction says they are the same', 'STRASSE'.toUpperCase() === 'straße'.toUpperCase(), true);

1
2
3
4
5
6
7
8
9
10test('each word is capitalised', titleCase('the quick brown fox'), 'The Quick Brown Fox');
test('an empty string stays empty', titleCase(''), '');
test('the gap between words is preserved exactly', titleCase('a  b'), 'A  B');
test('already-capitalised text is unchanged', titleCase('Hi There'), 'Hi There');
test('an apostrophe does not start a new word', titleCase("don't stop"), "Don't Stop");
test('but the word-boundary version thinks it does', byWordBoundary("don't stop"), "Don'T Stop");
test('only the first letter changes, so camelCase survives oddly', titleCase('iPhone repair'), 'IPhone Repair');
test('and shouting text is left shouting', titleCase('LAGOS'), 'LAGOS');
test('one word is still title cased', titleCase('lagos'), 'Lagos');
test('a leading space produces an empty first word, harmlessly', titleCase(' lagos'), ' Lagos');

1
2
3
4
5
6
7
8
9
10test('snake_case becomes camelCase', toCamel('total_price'), 'totalPrice');
test('kebab-case does too', toCamel('total-price'), 'totalPrice');
test('several words in a row', toCamel('a_b_c'), 'aBC');
test('SHOUTING_SNAKE works because of the lower-casing', toCamel('TOTAL_PRICE'), 'totalPrice');
test('a word with no separator is unchanged', toCamel('price'), 'price');
test('the empty string stays empty', toCamel(''), '');
test('a trailing separator has nothing to promote, so it survives', toCamel('price_'), 'price_');
test('a doubled separator only loses one of the two', toCamel('a__b'), 'a_b');
test('and lower-casing first DESTROYS input that was already camelCase', toCamel('totalPrice'), 'totalprice');
test('so only convert when you know what shape the input is in', toCamel('order-id'), 'orderId');

1
2
3
4
5
6
7
8
9
10test('camelCase becomes snake_case', toSnake('totalPrice'), 'total_price');
test('and kebab-case', toKebab('totalPrice'), 'total-price');
test('a leading capital would leave a stray separator, so it is stripped', toSnake('TotalPrice'), 'total_price');
test('a single word is unchanged', toSnake('price'), 'price');
test('the empty string stays empty', toSnake(''), '');
test('an acronym is split letter by letter, which is rarely wanted', toSnake('orderID'), 'order_i_d');
test('three words come out cleanly', toKebab('shippingAddressLine'), 'shipping-address-line');
test('digits stay where they are', toSnake('line1Total'), 'line1_total');
test('the round trip back to camelCase works', toCamel(toSnake('totalPrice')), 'totalPrice');
test('and it even survives the ugly acronym', toCamel(toSnake('orderID')), 'orderID');

1
2
3
4
5
6
7
8
9
10test('trim takes whitespace off both ends', messy.trim(), 'Lagos');
test('trimStart takes it off the front only', messy.trimStart(), 'Lagos   ');
test('trimEnd takes it off the back only', messy.trimEnd(), '   Lagos');
test('none of them touch the middle', '  a  b  '.trim(), 'a  b');
test('tabs and newlines count as whitespace', '\t\nLagos\n'.trim(), 'Lagos');
test('a string of only spaces trims to empty', '   '.trim(), '');
test('which is how a blank form field is usually detected', '   '.trim().length === 0, true);
test('a non-breaking space is trimmed too', '\u00a0Lagos'.trim(), 'Lagos');
test('the original is never modified', messy, '   Lagos   ');
test('so trimming twice changes nothing further', messy.trim().trim(), 'Lagos');

1
2
3
4
5
6
7
8
9
10test('padStart pads on the left to a total length', '7'.padStart(3, '0'), '007');
test('padEnd pads on the right', 'ab'.padEnd(5, '.'), 'ab...');
test('the default filler is a space', 'ab'.padStart(4), '  ab');
test('the argument is the total length, not the amount added', '7'.padStart(3, '0').length, 3);
test('a target shorter than the string does nothing', 'lagos'.padStart(2, '0'), 'lagos');
test('so padding never truncates', 'lagos'.padStart(2, '0').length, 5);
test('a multi-character filler repeats and is cut to fit', 'x'.padEnd(6, 'ab'), 'xababa');
test('an empty filler pads nothing at all', 'x'.padStart(5, ''), 'x');
test('padding to the same length is a no-op', 'abc'.padStart(3, '0'), 'abc');
test('and the original is never modified', (() => { const s = '7'; s.padStart(3, '0'); return s; })(), '7');

1
2
3
4
5
6
7
8
9
10test('a single digit gains a zero', pad2(7), '07');
test('two digits are left alone', pad2(23), '23');
test('zero becomes 00', pad2(0), '00');
test('a clock reads properly', clock(9, 5), '09:05');
test('and at midnight', clock(0, 0), '00:00');
test('padStart is a string method, so the result is a string', typeof pad2(7), 'string');
test('converting back loses the padding, because numbers have no leading zeros', Number(pad2(7)), 7);
test('three digits overflow the field rather than being cut', pad2(123), '123');
test('so widen the field when the range is bigger', String(123).padStart(4, '0'), '0123');
test('an invoice number, six wide', String(42).padStart(6, '0'), '000042');

1
2
3
4
5
6
7
8
9test('the widest number sets the column', width, 5);
test('the first row', table[0], 'Rice......  4500');
test('the longest name is padded least', table[1], 'Palm oil.. 12000');
test('every line is the same width', table.map((l) => l.length), [16, 16, 16]);
test('so the amounts all end at the same column', table.every((l) => l.length === table[0].length), true);
test('right alignment is padStart on the number', String(300).padStart(6), '   300');
test('left alignment is padEnd on the name', 'Salt'.padEnd(10, '.'), 'Salt......');
test('a name longer than the column is NOT cut by padding', 'A very long product'.padEnd(10, '.'), 'A very long product');
test('so slice first when the width is a hard limit', 'A very long product'.slice(0, 10).padEnd(10, '.'), 'A very lon');

1
2
3
4
5
6
7
8
9
10test('split on a comma gives the fields', csv.split(','), ['rice', 'beans', 'yam']);
test('a separator that is not there gives one element', csv.split(';'), ['rice,beans,yam']);
test('no separator at all also gives one element', csv.split(), ['rice,beans,yam']);
test('a trailing separator produces an empty last field', 'a,b,'.split(','), ['a', 'b', '']);
test('and a leading one an empty first field', ',a'.split(','), ['', 'a']);
test('consecutive separators leave empties between them', 'a,,b'.split(','), ['a', '', 'b']);
test('splitting an empty string on a comma gives ONE empty field', ''.split(','), ['']);
test('but splitting it on nothing gives no fields at all', ''.split(''), []);
test('a multi-character separator works', 'a -> b -> c'.split(' -> '), ['a', 'b', 'c']);
test('split and join are inverses with the same separator', csv.split(',').join(','), csv);

1
2
3
4
5
6
7
8
9
10test('a pattern separator can absorb the spaces around the comma', line.split(/\s*,\s*/), ['rice', 'beans', 'yam']);
test('a plain comma leaves them behind', line.split(','), ['rice ', '  beans', 'yam']);
test('the limit caps how many fields come back', 'a,b,c,d'.split(',', 2), ['a', 'b']);
test('the remainder is DISCARDED, not returned as a tail', 'a,b,c,d'.split(',', 2).length, 2);
test('so slice and rejoin when you want the rest', (() => { const p = 'a,b,c,d'.split(','); return [p[0], p.slice(1).join(',')]; })(), ['a', 'b,c,d']);
test('a capture group in the separator is KEPT in the output', 'a1b2c'.split(/([0-9])/), ['a', '1', 'b', '2', 'c']);
test('without the group the digits vanish', 'a1b2c'.split(/[0-9]/), ['a', 'b', 'c']);
test('splitting on whitespace handles runs of it', 'a   b\tc'.split(/\s+/), ['a', 'b', 'c']);
test('but a leading space then gives an empty first field', ' a b'.split(/\s+/), ['', 'a', 'b']);
test('which is why trim comes first', ' a b '.trim().split(/\s+/), ['a', 'b']);

1
2
3
4
5
6
7
8
9
10
11test('join with a comma and a space', items.join(', '), 'rice, beans, yam');
test('the default separator is a bare comma', items.join(), 'rice,beans,yam');
test('an empty separator glues them together', items.join(''), 'ricebeansyam');
test('one item needs no separator', ['rice'].join(', '), 'rice');
test('an empty array joins to an empty string', [].join(', '), '');
test('null and undefined become EMPTY, not the words', ['a', null, undefined, 'b'].join('-'), 'a---b');
test('even though String(null) is the word', String(null), 'null');
test('numbers are converted for you', [1, 2, 3].join('+'), '1+2+3');
test('a nested array is joined too, with commas', [['a', 'b'], 'c'].join('-'), 'a,b-c');
test('a readable list needs more than join', sentence(items), 'rice, beans and yam');
test('and it still handles a single item', sentence(['rice']), 'rice');

1
2
3
4
5
6
7
8
9
10test('for plain text both give the same characters', 'Lagos'.split(''), ['L', 'a', 'g', 'o', 's']);
test('and spreading agrees', [...'Lagos'], ['L', 'a', 'g', 'o', 's']);
test('the emoji string is three characters', [...emoji].length, 3);
test('but split MANGLES it into four pieces', emoji.split('').length, 4);
test('spreading keeps the emoji whole', [...emoji][1], '👍');
test('split does not', emoji.split('')[1] === '👍', false);
test('because length counts UTF-16 code units', emoji.length, 4);
test('Array.from behaves like spreading', Array.from(emoji).length, 3);
test('joining the split halves straight back does restore the text', emoji.split('').join(''), emoji);
test('but reordering them does not', emoji.split('').reverse().join('') === [...emoji].reverse().join(''), false);

1
2
3
4
5
6
7
8
9
10test('replace changes only the FIRST match', line.replace('the', 'a'), 'a cat sat on the mat');
test('so the second one is still there', line.replace('the', 'a').includes('the'), true);
test('a regex with g changes them all', line.replace(/the/g, 'a'), 'a cat sat on a mat');
test('a needle that is absent gives the string back unchanged', line.replace('dog', 'cow'), line);
test('the search is case sensitive', line.replace('The', 'a'), line);
test('replacing with an empty string deletes the match', line.replace('the ', ''), 'cat sat on the mat');
test('the replacement is NOT re-scanned, so it cannot loop', 'aaa'.replace('a', 'aa'), 'aaaa');
test('a $ in the replacement is special: $& is the match', 'price'.replace('price', '$&$&'), 'priceprice');
test('so a literal dollar has to be written $$', 'price'.replace('price', '$$'), '$');
test('and the original is unchanged either way', line, 'the cat sat on the mat');

1
2
3
4
5
6
7
8
9
10test('replaceAll changes every occurrence', line.replaceAll('the', 'a'), 'a cat sat on a mat');
test('which matches the regex-with-g version', line.replaceAll('the', 'a'), line.replace(/the/g, 'a'));
test('an absent needle changes nothing', line.replaceAll('dog', 'cow'), line);
test('a non-global regex is REFUSED rather than treated as one match', withoutG, 'TypeError');
test('with the g flag it is fine', line.replaceAll(/the/g, 'a'), 'a cat sat on a mat');
test('a string needle needs no escaping', 'a.b.c'.replaceAll('.', '-'), 'a-b-c');
test('while a regex dot matches every character', 'a.b.c'.replace(/./g, '-'), '-----');
test('an empty needle inserts between every character', 'abc'.replaceAll('', '-'), '-a-b-c-');
test('overlapping matches are not revisited', 'aaaa'.replaceAll('aa', 'a'), 'aa');
test('so run it again to reach a fixed point', 'aaaa'.replaceAll('aa', 'a').replaceAll('aa', 'a'), 'a');

1
2
3
4
5
6
7
8
9
10test('capture groups can be reordered', swapDate('2025-04-09'), '09/04/2025');
test('$& is the whole match', 'lagos'.replace(/lagos/, '[$&]'), '[lagos]');
test('$` is everything before the match', 'ab'.replace(/b/, '<$`>'), 'a<a>');
test("$' is everything after it", 'ab'.replace(/a/, "<$'>"), '<b>b');
test('$$ is a literal dollar sign', 'x'.replace(/x/, '$$'), '$');
test('a named group is referenced as $<name>', '2025-04'.replace(/(?<y>[0-9]{4})-(?<m>[0-9]{2})/, '$<m> of $<y>'), '04 of 2025');
test('a group number that does not exist stays as text', 'a'.replace(/(a)/, '$2'), '$2');
test('and $0 is not a thing either', 'a'.replace(/a/, '$0'), '$0');
test('grouping a phone number', '08031234567'.replace(/([0-9]{4})([0-9]{3})([0-9]{4})/, '$1 $2 $3'), '0803 123 4567');
test('wrapping every match needs g as well as $&', 'a b'.replace(/[a-z]/g, '[$&]'), '[a] [b]');

1
2
3
4
5
6
7
8
9
10test('the function receives each match', shoutWords('a bc'), 'A BC');
test('and can compute the replacement', bump('room 9 and room 10'), 'room 10 and room 11');
test('the arguments are match, groups, offset', 'ab'.replace(/(a)(b)/, (m, g1, g2, offset) => [m, g1, g2, offset].join('|')), 'ab|a|b|0');
test('and then the whole input string', 'ab'.replace(/b/, (...args) => String(args.at(-1))), 'aab');
test('named groups arrive as one final object', '2025-04'.replace(/(?<y>[0-9]{4})-(?<m>[0-9]{2})/, (...a) => a.at(-1).m), '04');
test('a counter can number the matches', numberEach('a a a'), '1 2 3');
test('nothing in the returned string is interpreted, so no $ escaping', 'x'.replace(/x/, () => '$&'), '$&');
test('a non-string return value is converted', 'x'.replace(/x/, () => 42), '42');
test('without g the function runs once', (() => { let n = 0; 'aaa'.replace(/a/, () => { n++; return 'b'; }); return n; })(), 1);
test('with g it runs once per match', (() => { let n = 0; 'aaa'.replace(/a/g, () => { n++; return 'b'; }); return n; })(), 3);

1
2
3
4
5
6
7
8
9
10
11test('a dot comes back with a backslash in front of it', escapeRegExp('a.b'), 'a' + BACKSLASH + '.b');
test('which is one character longer than the input', escapeRegExp('a.b').length, 4);
test('the escaped pattern matches the literal text', new RegExp(escapeRegExp('a.b')).test('a.b'), true);
test('and nothing else', new RegExp(escapeRegExp('a.b')).test('axb'), false);
test('unescaped, the dot is a wildcard', new RegExp('a.b').test('axb'), true);
test('ordinary text is left completely alone', escapeRegExp('lagos 2025'), 'lagos 2025');
test('every metacharacter is covered', [...'.*+?^${}()|[]'].every((c) => escapeRegExp(c) === BACKSLASH + c), true);
test('including the backslash itself', escapeRegExp(BACKSLASH), BACKSLASH + BACKSLASH);
test('so a needle typed by a user is now safe to search for', highlightAll('a.b.c', '.'), 'a[.]b[.]c');
test('where the unescaped version would have matched everything', 'a.b.c'.replace(/./g, '[$&]'), '[a][.][b][.][c]');
test('and a stray bracket no longer throws a SyntaxError', highlightAll('cost [x]', '['), 'cost [[]x]');

1
2
3
4
5
6
7
8
9
10test('the two forms produce the same text', byTemplate, byConcat);
test('and it reads properly', byTemplate, 'Ada has 3 items');
test('one item drops the s', `1 item${1 === 1 ? '' : 's'}`, '1 item');
test('a template literal keeps the newline you typed', address.split('\n').length, 2);
test('a quoted string needs the escape instead', 'a\nb'.split('\n').length, 2);
test('a number is converted inside a hole', `n=${42}`, 'n=42');
test('and so is null, as the word', `v=${null}`, 'v=null');
test('+ adds two numbers before it meets the string', 1 + 2 + 'x', '3x');
test('but joins from the start in the other order', 'x' + 1 + 2, 'x12');
test('a hole can hold any expression at all', `${[1, 2, 3].join('-')}`, '1-2-3');

1
2
3
4
5
6
7
8
9
10test('repeat makes n copies', 'ab'.repeat(3), 'ababab');
test('zero copies is an empty string', 'ab'.repeat(0), '');
test('one copy is the string itself', 'ab'.repeat(1), 'ab');
test('a fractional count is truncated, not rounded', 'ab'.repeat(2.9), 'abab');
test('a negative count throws a RangeError', negative, 'RangeError');
test('a rule of the width asked for', rule(30).length, 30);
test('an indent of two spaces per level', '  '.repeat(3) + 'deep', '      deep');
test('repeating an empty string gives an empty string', ''.repeat(100), '');
test('repeat and padEnd overlap for simple filling', 'x' + '.'.repeat(4), 'x'.padEnd(5, '.'));
test('and the original is unchanged', (() => { const s = 'ab'; s.repeat(3); return s; })(), 'ab');

1
2
3
4
5
6
7
8
9
10test('concat joins strings', 'a'.concat('b'), 'ab');
test('and takes several arguments', 'a'.concat('b', 'c', 'd'), 'abcd');
test('plus does the same and reads better', 'a' + 'b' + 'c' + 'd', 'abcd');
test('concat converts its arguments', 'n='.concat(42), 'n=42');
test('concat with no arguments returns a copy', 'a'.concat(), 'a');
test('an array of pieces is better joined', pieces.join(''), 'abc');
test('+= in a loop works', byLoop, 'ABC');
test('and map-then-join gives the same answer', byJoin, 'ABC');
test('strings are immutable, so concat returns a new one', (() => { const a = 'x'; const b = a.concat('y'); return [a, b]; })(), ['x', 'xy']);
test('and += rebinds rather than modifying', (() => { const a = 'x'; let b = a; b += 'y'; return a; })(), 'x');

1
2
3
4
5
6
7
8
9
10
11test('the letters of banana', countCharacters('banana'), { b: 1, a: 3, n: 2 });
test('an empty string has no counts', countCharacters(''), {});
test('spaces are characters too', countCharacters('a a')[' '], 1);
test('case is not folded', countCharacters('Aa'), { A: 1, a: 1 });
test('the commonest letter, with its count', mostCommon('banana'), ['a', 3]);
test('for...of walks code points, so an emoji counts once', countCharacters('a👍👍')['👍'], 2);
test('the totals add up to the number of code points', Object.values(countCharacters('banana')).reduce((a, b) => a + b, 0), 6);
test('digit keys are pulled to the front, because they look like indexes', Object.keys(countCharacters('2211')), ['1', '2']);
test('a Map keeps the order they arrived in', [...countByMap('2211').keys()], ['2', '1']);
test('a plain object already has an inherited constructor property', typeof countCharacters('x').constructor, 'function');
test('which a Map is immune to', countByMap('x').get('constructor'), undefined);

1
2
3
4
5
6
7
8
9
10test('three words', countWords('the quick fox'), 3);
test('extra spaces between words add nothing', countWords('the   quick   fox'), 3);
test('leading and trailing spaces are trimmed first', countWords('  hi  '), 1);
test('an empty string has no words', countWords(''), 0);
test('and neither does a string of only spaces', countWords('   '), 0);
test('without the guard the split would have reported two', '   '.split(/\s+/).length, 2);
test('newlines and tabs separate words too', countWords('a\nb\tc'), 3);
test('a hyphenated word counts as one', countWords('well-known fact'), 2);
test('punctuation does not split a word either', countWords('hi, there!'), 2);
test('so "word" here means a run of non-whitespace', countWords("it's fine"), 2);

1
2
3
4
5
6
7
8
9
10test('a short word', countVowels('lagos'), 2);
test('the i flag makes it case-insensitive', countVowels('LAGOS'), 2);
test('no vowels gives zero, not null', countVowels('rhythm'), 0);
test('match itself returns null, which is why the default is there', 'rhythm'.match(/[aeiou]/gi), null);
test('an empty string has none', countVowels(''), 0);
test('y is not counted here', countVowels('sky'), 0);
test('a vowel-only string counts every letter', countVowels('aeiou'), 5);
test('a sentence', countVowels('the quick brown fox'), 5);
test('an accented vowel is NOT in the character class', countVowels('café'), 1);
test('decomposing first separates the e from its accent', countVowels('café'.normalize('NFD')), 2);

1
2
3
4
5
6
7
8
9
10test('two occurrences in the sentence', countOccurrences('the cat sat on the mat', 'the'), 2);
test('nothing found is zero', countOccurrences('the cat', 'dog'), 0);
test('non-overlapping counting gives 2 for aa in aaaa', countOccurrences('aaaa', 'aa'), 2);
test('counting overlaps gives 3', countOverlapping('aaaa', 'aa'), 3);
test('the split trick agrees with the non-overlapping version', 'aaaa'.split('aa').length - 1, 2);
test('and so does a global regex', ('aaaa'.match(/aa/g) || []).length, 2);
test('so a regex cannot count overlaps either', ('aaaa'.match(/aa/g) || []).length !== countOverlapping('aaaa', 'aa'), true);
test('the empty needle is refused rather than looping forever', countOccurrences('abc', ''), 0);
test('while the split trick would have claimed two', 'abc'.split('').length - 1, 2);
test('counting is case sensitive', countOccurrences('The the', 'the'), 1);

1
2
3
4
5
6
7
8
9
10test('a plain word reverses', reverse('lagos'), 'sogal');
test('an empty string reverses to itself', reverse(''), '');
test('and so does a single character', reverse('a'), 'a');
test('reversing twice returns the original', reverse(reverse('lagos')), 'lagos');
test('spaces move like anything else', reverse('a b'), 'b a');
test('for plain text both versions agree', reverseByCodePoint('lagos'), 'sogal');
test('but split BREAKS the emoji, because it cuts code units apart', reverse('ab👍') === '👍ba', false);
test('spreading keeps it whole', reverseByCodePoint('ab👍'), '👍ba');
test('the broken result still has the right number of code units', reverse('ab👍').length, 4);
test('it is the ORDER of the two halves that is wrong', reverse('ab👍').slice(0, 2) === '👍', false);

1
2
3
4
5
6
7
8
9
10
11test('the word is five code points but four graphemes', [decomposed.length, graphemes(decomposed).length], [5, 4]);
test('reversing by code point puts the accent on the wrong letter', reverseCodePoints(decomposed) === 'e\u0301fac', false);
test('grouping the mark with its letter fixes it', reverseGraphemes(decomposed), 'e\u0301fac');
test('a plain word is unaffected either way', [reverseCodePoints('lagos'), reverseGraphemes('lagos')], ['sogal', 'sogal']);
test('an astral character survives, since both work above code units', reverseGraphemes('ab👍'), '👍ba');
test('unlike split, which works in code units', 'ab👍'.split('').reverse().join('') === '👍ba', false);
test('reversing twice gets the graphemes back', reverseGraphemes(reverseGraphemes(decomposed)), decomposed);
test('a ZWJ emoji is beyond the mark-based version', reverseGraphemes(family) === family, false);
test('because a zero-width joiner is not a combining mark', /\p{M}/u.test('\u200D'), false);
test('Intl.Segmenter handles that one', hasSegmenter ? reverseBySegmenter(family) === family : true, true);
test('and it agrees with the mark version on the accented word', reverseBySegmenter(decomposed), reverseGraphemes(decomposed));

1
2
3
4
5
6
7
8
9
10
11test('a plain palindrome', isStrictPalindrome('racecar'), true);
test('a capital letter breaks the strict version', isStrictPalindrome('Racecar'), false);
test('cleaning first fixes that', isPalindrome('Racecar'), true);
test('punctuation and spaces are ignored once cleaned', isPalindrome('A man, a plan, a canal: Panama'), true);
test('digits count as characters', isPalindrome('12321'), true);
test('a date-shaped one', isPalindrome('02/02/2020'), true);
test('a non-palindrome is rejected', isPalindrome('lagos'), false);
test('the empty string passes, by convention', isPalindrome(''), true);
test('and so does a string of only punctuation, which may surprise you', isPalindrome('!!!'), true);
test('because cleaning removed everything', clean('!!!'), '');
test('the a-z class also strips accents, changing the meaning of the word', clean('Ésope'), 'sope');