JavaScript: String, 41–63

1
2
3
4
5
6
7
8
9
10
11test('listen and silent', isAnagram('listen', 'silent'), true);
test('case is folded', isAnagram('Listen', 'SILENT'), true);
test('spaces and punctuation are ignored', isAnagram('Dormitory', 'dirty room'), true);
test('different letters are not anagrams', isAnagram('lagos', 'kano'), false);
test('the same letters in different amounts are not either', isAnagram('aab', 'abb'), false);
test('a word is an anagram of itself', isAnagram('lagos', 'lagos'), true);
test('two empty strings are anagrams', isAnagram('', ''), true);
test('sorting is what makes the comparison work', normalise('silent'), 'eilnst');
test('sort compares code units, so digits come before letters', normalise('a1'), '1a');
test('equal length is not enough on its own', isAnagram('abc', 'abd'), false);
test('the counting version agrees everywhere', [['listen', 'silent'], ['aab', 'abb'], ['abc', 'abd'], ['', '']].every(([a, b]) => isAnagramByCount(a, b) === isAnagram(a, b)), true);

1
2
3
4
5
6
7
8
9
10
11test('a word with no repeats', isIsogram('lumberjack'), true);
test('a repeat is caught', isIsogram('lagos state'), false);
test('and it can be named', firstRepeat('lagos state'), 's');
test('case does not hide a repeat', isIsogram('Abba'), false);
test('spaces and hyphens are stripped, not counted', isIsogram('six-year-old'), true);
test('the empty string is an isogram', isIsogram(''), true);
test('and so is a single letter', isIsogram('a'), true);
test('a Set drops duplicates, which is the whole trick', new Set('abba').size, 2);
test('while length keeps them', 'abba'.length, 4);
test('digits are stripped, so a repeated digit does not disqualify it', isIsogram('a11'), true);
test('the long standard example', isIsogram('dermatoglyphics'), true);

1
2
3
4
5
6
7
8
9
10
11test('a thumbs-up is one character but length 2', thumbsUp.length, 2);
test('because length counts UTF-16 code units', [...thumbsUp].length, 1);
test('its code point is above the 16-bit range', thumbsUp.codePointAt(0), 128077);
test('so charCodeAt and codePointAt disagree', thumbsUp.charCodeAt(0) !== thumbsUp.codePointAt(0), true);
test('indexing gives you half a character', thumbsUp[0] === thumbsUp, false);
test('and that half is one code unit long', thumbsUp[0].length, 1);
test('slice(0, 1) cuts it in half too', thumbsUp.slice(0, 1) === thumbsUp, false);
test('while spreading and re-joining is safe', [...thumbsUp].join(''), thumbsUp);
test('a mixed string over-counts with length', mixed.length, 8);
test('and counts correctly by code point', [...mixed].length, 7);
test('so a length limit has to be measured in the unit you meant', [...mixed].slice(0, 7).join(''), 'Lagos 👍');

1
2
3
4
5
6
7
8
9
10
11test('the two look the same and are not equal', composed === decomposed, false);
test('because they are different lengths', [composed.length, decomposed.length], [4, 5]);
test('NFC composes the mark into one character', decomposed.normalize('NFC'), composed);
test('NFD takes it back apart', composed.normalize('NFD'), decomposed);
test('NFC is the default form', decomposed.normalize(), composed);
test('so normalising both sides makes the comparison work', composed.normalize('NFC') === decomposed.normalize('NFC'), true);
test('the composed form is four code units long', decomposed.normalize('NFC').length, 4);
test('includes fails on the decomposed form', decomposed.includes('\u00e9'), false);
test('and works once it is normalised', decomposed.normalize('NFC').includes('\u00e9'), true);
test('stripping accents is NFD then dropping the marks', strip(decomposed), 'cafe');
test('which works on the composed form too', strip(composed), 'cafe');

1
2
3
4
5
6
7
8
9
10
11test('the default sort uses code units, so accents land at the end', byCodeUnit, ['Ada', 'Zoe', 'Ölaf', 'ándre']);
test('localeCompare puts them where a reader expects', byLocale, ['Ada', 'ándre', 'Ölaf', 'Zoe']);
test('code-unit sorting also separates the cases', ['b', 'A', 'a', 'B'].sort(), ['A', 'B', 'a', 'b']);
test('while locale sorting keeps each letter together', ['b', 'A', 'a', 'B'].sort((x, y) => x.localeCompare(y, 'en')).map((s) => s.toLowerCase()), ['a', 'a', 'b', 'b']);
test('localeCompare returns 0 for equal strings', 'a'.localeCompare('a'), 0);
test('an accent is a difference at the default sensitivity', 'e'.localeCompare('é', 'en') !== 0, true);
test('but not at sensitivity base', 'e'.localeCompare('é', 'en', { sensitivity: 'base' }), 0);
test('numeric collation compares digit runs as numbers', '10'.localeCompare('9', 'en', { numeric: true }) > 0, true);
test('without it, 10 sorts before 9', '10'.localeCompare('9', 'en') < 0, true);
test('which is the same answer the < operator gives', '10' < '9', true);
test('sorting a copy leaves the original alone', names[0], 'Ölaf');

1
2
3
4
5
6
7
8
9
10test('all but the last four are hidden', mask('4111111111111111'), '************1111');
test('the width is unchanged', mask('4111111111111111').length, 16);
test('keeping two instead of four', mask('987654', 2), '****54');
test('a number shorter than the tail is returned whole', mask('123'), '123');
test('keeping none does NOT hide everything, because slice(-0) is slice(0)', mask('9876', 0), '9876');
test('an explicit check is the fix', maskSafe('9876', 0), '****');
test('spaces in the input inflate the mask', mask('4111 1111 1111 1111').length, 19);
test('so strip them first', mask('4111 1111 1111 1111'.replace(/\s/g, '')), '************1111');
test('the visible tail is exactly the last four characters', mask('4111111111111111').slice(-4), '1111');
test('and nothing but stars comes before it', /^[*]+$/.test(mask('4111111111111111').slice(0, -4)), true);

1
2
3
4
5
6
7
8
9
10test('a short string is returned untouched', truncate(line, 30), line);
test('exactly the limit is untouched too', truncate(line, 25), line);
test('a cut that lands on a space keeps the whole word', truncate(line, 10), 'The quick…');
test('a cut mid-word steps back to the space', truncate(line, 12), 'The quick…');
test('so the result can be shorter than the limit', truncate(line, 12).length <= 12, true);
test('the ellipsis is ONE character, not three dots', '…'.length, 1);
test('a single long word is cut hard, having no space to step back to', truncate('Antidisestablishmentarianism', 10), 'Antidises…');
test('a double space leaves no gap before the ellipsis', truncate('The  quick brown', 8), 'The…');
test('and the tiniest limit still fits', truncate(line, 3), 'Th…');
test('every result respects the limit', [30, 25, 12, 10, 4, 3].every((n) => truncate(line, n).length <= n), true);

1
2
3
4
5
6
7
8
9
10test('the classic example', slugify('Hello, World!'), 'hello-world');
test('a run of punctuation and space collapses to one dash', slugify('C++ & C#'), 'c-c');
test('leading and trailing dashes are trimmed', slugify('  Spaced  Out  '), 'spaced-out');
test('accents are folded to their base letters', slugify('Café Déjà Vu'), 'cafe-deja-vu');
test('digits survive', slugify('2025 Q1 Report'), '2025-q1-report');
test('a slug is already a slug, so it is idempotent', slugify(slugify('Hello, World!')), 'hello-world');
test('a heading of only punctuation slugs to nothing', slugify('---'), '');
test('which is why an empty slug needs a fallback', slugify('---') || 'untitled', 'untitled');
test('a non-Latin heading is DESTROYED by the a-z filter', slugify('Лагос'), '');
test('so filter on the letter category instead when that matters', 'Лагос'.toLowerCase().replace(/[^\p{L}\p{N}]+/gu, '-'), 'лагос');

1
2
3
4
5
6
7
8
9
10test('two names give two letters', initials('Ada Lovelace'), 'AL');
test('extra whitespace is ignored', initials('  ada   lovelace  '), 'AL');
test('three names give three', initials('Chimamanda Ngozi Adichie'), 'CNA');
test('an empty name gives an empty string rather than throwing', initials(''), '');
test('the filter is what prevents that, because splitting "" gives one empty field', ''.split(/\s+/), ['']);
test('a hyphenated surname counts as one word', initials('Ama Ata-Aidoo'), 'AA');
test('splitting on the hyphen too would give three', 'Ama Ata-Aidoo'.split(/[\s-]+/).map((w) => w[0]).join(''), 'AAA');
test('capping at two is a slice, not a different algorithm', initials('Chimamanda Ngozi Adichie').slice(0, 2), 'CN');
test('w[0] takes half an astral character', initials('👍 ok')[0] === '👍', false);
test('spreading the word first fixes it', initialsSafe('👍 ok'), '👍O');

1
2
3
4
5
6
7
8
9
10test('four digits gain one comma', group(4500), '4,500');
test('seven digits gain two', group(1000000), '1,000,000');
test('three or fewer gain none', group(999), '999');
test('zero is left alone', group(0), '0');
test('a negative keeps its sign outside the grouping', group(-4500), '-4,500');
test('a decimal part is left ungrouped', group(1234.5678), '1,234.5678');
test('the built-in agrees on the whole numbers', (4500).toLocaleString('en-US'), '4,500');
test('the popular one-liner also works, up to a point', byRegex(4500), '4,500');
test('but it groups the DECIMALS, which is wrong', byRegex(1234.5678), '1,234.5,678');
test('splitting on the dot first is the fix', group(1234.5678).split('.')[1], '5678');

1
2
3
4
5
6
7
8
9
10
11
12test('two identical strings are equal', 'lagos' === 'lagos', true);
test('there is no separate identity to worry about', 'la' + 'gos' === 'lagos', true);
test('case matters', 'Lagos' === 'lagos', false);
test('a trailing space matters', 'lagos ' === 'lagos', false);
test('< compares code unit by code unit, like a dictionary', 'apple' < 'banana', true);
test("so '10' is less than '9', because '1' sorts before '9'", '10' < '9', true);
test('while the numbers compare the other way', 10 < 9, false);
test('== between a string and a number converts the string', '10' == 10, true);
test('=== does not, so it is false', '10' === 10, false);
test('a prefix sorts before the longer string', 'lag' < 'lagos', true);
test('and the empty string sorts before everything', '' < 'a', true);
test('every capital sorts before every lower-case letter', 'Z' < 'a', true);

1
2
3
4
5
6
7
8
9
10test('the default sort is lexical, so 10 comes before 9', lexical, ['file1.txt', 'file10.txt', 'file9.txt']);
test('numeric collation reads the digits as a number', natural, ['file1.txt', 'file9.txt', 'file10.txt']);
test('a reusable collator gives the same order', ['b10', 'b9'].sort(naturally), ['b9', 'b10']);
test('sort with no comparator converts to strings, even for numbers', [10, 9, 1].sort(), [1, 10, 9]);
test('which is why numbers need one', [10, 9, 1].sort((a, b) => a - b), [1, 9, 10]);
test('sort mutates, so the original list was copied', files, ['file10.txt', 'file9.txt', 'file1.txt']);
test('zero-padding makes the lexical sort correct with no collator', ['file09', 'file10'].sort(), ['file09', 'file10']);
test('which is the whole reason for naming things 001, 002', ['002', '001', '010'].sort(), ['001', '002', '010']);
test('case-insensitive sorting is a sensitivity, not a toLowerCase', ['b', 'A'].sort(new Intl.Collator('en', { sensitivity: 'base' }).compare), ['A', 'b']);
test('and numeric collation leaves letters alone', ['b', 'a'].sort(naturally), ['a', 'b']);

1
2
3
4
5
6
7
8
9
10test('the classic example', longestCommonPrefix(['flower', 'flow', 'flight']), 'fl');
test('no shared start gives an empty string', longestCommonPrefix(['dog', 'racecar', 'car']), '');
test('one word is its own prefix', longestCommonPrefix(['single']), 'single');
test('an empty list has no prefix', longestCommonPrefix([]), '');
test('an empty word in the list forces an empty prefix', longestCommonPrefix(['abc', '']), '');
test('identical words give the whole word', longestCommonPrefix(['abc', 'abc']), 'abc');
test('the comparison is case sensitive', longestCommonPrefix(['Flow', 'flower']), '');
test('a shared path prefix, which is what this is usually for', longestCommonPrefix(['/usr/local/bin', '/usr/local/lib', '/usr/lib']), '/usr/l');
test('the sorted two-extremes version gives the same answer', byExtremes(['flower', 'flow', 'flight']), 'fl');
test('and agrees on every case above', [['flower', 'flow', 'flight'], ['dog', 'racecar', 'car'], ['abc', 'abc'], ['abc', ''], ['single'], []].every((list) => byExtremes(list) === longestCommonPrefix(list)), true);

1
2
3
4
5
6
7
8
9
10test('the classic example', longestUnique('abcabcbb'), 'abc');
test('all the same character gives one', longestUnique('bbbbb'), 'b');
test('the window moves past the repeat rather than restarting', longestUnique('pwwkew'), 'wke');
test('a string with no repeats is its own answer', longestUnique('abcdef'), 'abcdef');
test('an empty string gives an empty answer', longestUnique(''), '');
test('the case that catches a naive reset to zero', longestUnique('dvdf'), 'vdf');
test('and the one that catches a stale index', longestUnique('tmmzuxt'), 'mzuxt');
test('the answer never contains a repeat', new Set(longestUnique('tmmzuxt')).size, longestUnique('tmmzuxt').length);
test('the window works in code units, so its length is not a character count', longestUnique('👍👍').length, 2);
test('while the answer itself is one character', [...longestUnique('👍👍')].length, 1);

1
2
3
4
5
6
7
8
9
10
11test('the commonest word, with its count', top[0], ['the', 3]);
test('and the next', top[1], ['mat', 2]);
test('seven distinct words', freq.size, 7);
test('the full stop is not part of a word', freq.get('mat'), 2);
test('case is folded, so The and the are one word', freq.get('the'), 3);
test('a word that is absent gives undefined, not zero', freq.get('lagos'), undefined);
test('the counts add up to the number of words', [...freq.values()].reduce((a, b) => a + b, 0), 10);
test('an apostrophe is kept inside a word', [...wordFrequency("it's it's").keys()], ["it's"]);
test('a Map is used because a word could be called constructor', wordFrequency('constructor').get('constructor'), 1);
test('where a plain object already has that name on it', typeof {}.constructor, 'function');
test('ties break alphabetically, so the tail is stable', top.slice(2).map(([w]) => w), ['cat', 'flat', 'on', 'sat', 'was']);

1
2
3
4
5
6
7
8
9
10
11test('three places forward', caesar('abc', 3), 'def');
test('the end of the alphabet wraps round', caesar('xyz', 3), 'abc');
test('case is preserved', caesar('Hello, World!', 3), 'Khoor, Zruog!');
test('punctuation and digits are left alone', caesar('a1!', 3), 'd1!');
test('a negative shift goes backwards and wraps', caesar('abc', -1), 'zab');
test('shifting by the alphabet length changes nothing', caesar('abc', 26), 'abc');
test('and 29 is the same as 3', caesar('abc', 29), caesar('abc', 3));
test('decoding is the same function with the opposite shift', caesar(caesar('Lagos 2025', 7), -7), 'Lagos 2025');
test('ROT13 is its own inverse', caesar(caesar('Lagos', 13), 13), 'Lagos');
test('an accented letter is outside a-zA-Z, so it is not shifted', caesar('café', 1), 'dbgé');
test('the length never changes', caesar('Hello, World!', 5).length, 'Hello, World!'.length);

1
2
3
4
5
6
7
8
9
10
11
12test('a run of three collapses', encode('aaabbc'), '3a2bc');
test('a single character carries no count', encode('abc'), 'abc');
test('an empty string encodes to nothing', encode(''), '');
test('a run of two', encode('aa'), '2a');
test('a run longer than nine uses two digits', encode('a'.repeat(12)), '12a');
test('the always-count variant writes a count every time', encodeStrict('aaabbc'), '3a2b1c');
test('which makes it longer than the input on text with no runs', encodeStrict('abc'), '1a1b1c');
test('measurably longer', encodeStrict('abc').length > 'abc'.length, true);
test('while the compact version never grows', encode('abc').length <= 'abc'.length, true);
test('but the compact output is AMBIGUOUS when the text has digits', encode('a3'), 'a3');
test('and the strict form does not rescue it either', encodeStrict('a3'), '1a13');
test('so run-length encoding needs an alphabet with no digits in it', /[0-9]/.test('aaabbc'), false);

1
2
3
4
5
6
7
8
9
10
11test('a count expands its character', decode('3a2bc'), 'aaabbc');
test('text with no counts decodes to itself', decode('abc'), 'abc');
test('an empty string decodes to nothing', decode(''), '');
test('a two-digit count is read as one number', decode('12a'), 'a'.repeat(12));
test('reading only one digit gets that badly wrong', decodeOneDigit('12a'), '1aa');
test('encode and decode round-trip on text with runs', decode(encode('aaabbcccc')), 'aaabbcccc');
test('and on text with none', decode(encode('abcdef')), 'abcdef');
test('a count of zero deletes the character', decode('0a'), '');
test('a trailing count has nothing to repeat, so it is left as text', decode('ab3'), 'ab3');
test('which means a malformed input fails silently rather than loudly', decode('3'), '3');
test('so validate the shape first if the input is not yours', /^([0-9]*[^0-9])*$/.test('3a2bc'), true);

1
2
3
4
5
6
7
8
9
10
11test('a matched set is balanced', isBalanced('(a[b]{c})'), true);
test('a mismatched pair is not', isBalanced('(]'), false);
test('an unclosed bracket is not', isBalanced('('), false);
test('a closer arriving first is not', isBalanced(')('), false);
test('an empty string is balanced', isBalanced(''), true);
test('text with no brackets is balanced', isBalanced('no brackets here'), true);
test('nesting several levels deep is fine', isBalanced('{[()()]}'), true);
test('one missing closer is caught by the empty-stack check', isBalanced('{[()()]'), false);
test('crossing pairs are NOT balanced', isBalanced('([)]'), false);
test('but a counter thinks they are, because it never checks the kind', byCounting('([)]'), true);
test('the counter does still catch a closer arriving first', byCounting(')('), false);

1
2
3
4
5
6
7
8
9
10test('the paragraph breaks into lines that fit', wrap(line, 10), ['The quick', 'brown fox', 'jumps over', 'the lazy', 'dog']);
test('no line is wider than the column', wrap(line, 10).every((l) => l.length <= 10), true);
test('a line that exactly fills the width is allowed', wrap(line, 10)[2].length, 10);
test('a wider column needs fewer lines', wrap(line, 20).length, 3);
test('an empty text wraps to no lines at all', wrap('', 10), []);
test('runs of whitespace are normalised to one space', wrap('a  b', 10), ['a b']);
test('a word longer than the column OVERFLOWS rather than breaking', wrap('Antidisestablishmentarianism', 10), ['Antidisestablishmentarianism']);
test('breaking it needs a deliberate hard break', hardBreak('Antidisestablishmentarianism', 10), ['Antidisest', 'ablishment', 'arianism']);
test('rendering is a join, and separate from the wrapping', wrap('a b c', 3).join('\n'), 'a b\nc');
test('no word is lost or duplicated', wrap(line, 10).join(' '), line);

1
2
3
4
5
6
7
8
9
10
11test('kitten to sitting', levenshtein('kitten', 'sitting'), 3);
test('flaw to lawn', levenshtein('flaw', 'lawn'), 2);
test('identical strings are zero apart', levenshtein('lagos', 'lagos'), 0);
test('an empty string costs one edit per character', levenshtein('', 'abc'), 3);
test('and the same the other way round', levenshtein('abc', ''), 3);
test('saturday to sunday', levenshtein('saturday', 'sunday'), 3);
test('the distance is symmetric', levenshtein('sitting', 'kitten'), levenshtein('kitten', 'sitting'));
test('a reversal costs two substitutions: there is no transpose operation', levenshtein('abc', 'cba'), 2);
test('the distance never exceeds the longer string', levenshtein('abc', 'wxyz') <= 4, true);
test('and the triangle inequality holds', levenshtein('kitten', 'sunday') <= levenshtein('kitten', 'sitting') + levenshtein('sitting', 'sunday'), true);
test('an emoji costs TWO edits, because the walk is over code units', levenshtein('👍', ''), 2);

1
2
3
4
5
6
7
8
9
10test('a run of spaces becomes one', squish('a    b'), 'a b');
test('leading and trailing whitespace goes', squish('   a b   '), 'a b');
test('tabs and newlines are whitespace too', squish('a\t\nb'), 'a b');
test('a paragraph folds onto one line', squish('one\n\ntwo\n\nthree'), 'one two three');
test('already-tidy text is unchanged', squish('a b c'), 'a b c');
test('whitespace-only text becomes empty', squish(' \t\n '), '');
test('a non-breaking space matches \\s, so it is REPLACED', squish('a\u00a0b'), 'a b');
test('and is therefore gone from the result', squish('a\u00a0b').includes('\u00a0'), false);
test('an explicit class is how you keep it', 'a\u00a0b'.replace(/[ \t\n]+/g, ' '), 'a\u00a0b');
test('trimming before or after gives the same answer', 'a  b '.replace(/\s+/g, ' ').trim(), squish('a  b '));

1
2
3
4
5
6
7
8
9
10test('the first column is capped at the limit', widths[0], 14);
test('the others are only as wide as their widest value', widths.slice(1), [3, 5]);
test('every line comes out the same width', new Set(table.map((l) => l.length)).size, 1);
test('which is the columns plus two separators', table[0].length, 14 + 3 + 5 + 6);
test('the header row reads properly', table[0], 'Product        | Qty | Price');
test('a short value is padded on the right', table[1], 'Rice, 50kg     | 2   | 45000');
test('an over-long value is cut and marked', table[3].slice(0, 14), 'Extremely lon…');
test('the ellipsis comes out of the budget, not on top of it', table[3].slice(0, 14).length, 14);
test('and the rest of that row still lines up', table[3].trimEnd(), 'Extremely lon… | 1   | 999');
test('left alignment is padEnd; a numeric column wants padStart instead', '999'.padStart(5), '  999');