JavaScript String Practice Programs with Solutions (32 Programs)

const title = 'Playwright Testing';
console.log(title.length);

Output

18

Explanation: length counts every character, including spaces.

const text = 'Login Page';
console.log(text.toUpperCase());
console.log(text.toLowerCase());

Output

LOGIN PAGE
login page

Explanation: case methods return new strings. The original string is unchanged.

const word = 'automation';
console.log(word[0]);
console.log(word.at(-1));

Output

a
n

Explanation: index 0 is the first character, and at(-1) reads from the end.

const raw = '   qa@example.com  ';
console.log(`[${raw.trim()}]`);
console.log(`[${raw.trimStart()}]`);

Output

[qa@example.com]
[qa@example.com  ]

Explanation: trim removes whitespace from both ends. trimStart and trimEnd remove one side only.

const message = 'Order placed successfully';
console.log(message.includes('success'));
console.log(message.includes('failed'));

Output

true
false

Explanation: includes returns true or false. It is case-sensitive.

const url = 'https://qa.shop.test/login';
console.log(url.startsWith('https://'));
console.log(url.endsWith('/login'));

Output

true
true

Explanation: these methods check the beginning or end of a string without regular expressions.

const tool = 'Playwright';
console.log(tool.slice(0, 4));
console.log(tool.slice(4));
console.log(tool.slice(-6));

Output

Play
wright
wright

Explanation: slice(start, end) stops before end. Negative numbers count from the end.

const url = 'https://staging.shop.test/staging/home';
console.log(url.replace('staging', 'qa'));
console.log(url.replaceAll('staging', 'qa'));
console.log('My First Test'.replaceAll(' ', '-'));

Output

https://qa.shop.test/staging/home
https://qa.shop.test/qa/home
My-First-Test

Explanation: replace changes only the first match. replaceAll changes every match.

const sentence = 'run tests in parallel';
const words = sentence.split(' ');
console.log(words);
console.log('Word count:', words.length);

Output

[ 'run', 'tests', 'in', 'parallel' ]
Word count: 4

Explanation: split turns a string into an array using a separator.

console.log('-'.repeat(20));
for (const id of [7, 42, 315]) console.log('TC-' + String(id).padStart(4, '0'));

Output

--------------------
TC-0007
TC-0042
TC-0315

Explanation: repeat duplicates a string, and padStart fills it to a fixed length.

const reversed = 'Playwright'.split('').reverse().join('');
console.log(reversed);

Output

thgirwyalP

Explanation: strings have no reverse, so split into characters, reverse the array and join it again.

const text = 'Never odd or even';
const clean = text.toLowerCase().replace(/[^a-z0-9]/g, '');
const isPalindrome = clean === [...clean].reverse().join('');
console.log(clean, isPalindrome);

Output

neveroddoreven true

Explanation: normalise the text first (lower case, letters only), then compare it with its reverse.

const text = 'test automation tutorial';
let count = 0;
for (const ch of text) if (ch === 't') count++;
console.log(count);
console.log(text.split('t').length - 1);

Output

6
6

Explanation: you can loop over characters, or split on the character and count the pieces minus one.

const title = 'checkout with saved card'
  .split(' ')
  .map(word => word[0].toUpperCase() + word.slice(1))
  .join(' ');
console.log(title);

Output

Checkout With Saved Card

Explanation: split into words, capitalise the first letter of each, and join them back.

const freq = {};
for (const ch of 'banana') freq[ch] = (freq[ch] || 0) + 1;
console.log(freq);

Output

{ b: 1, a: 3, n: 2 }

Explanation: an object works as a counter, with each character as a key.

const normalise = s => [...s.toLowerCase()].sort().join('');
console.log(normalise('listen') === normalise('silent'));
console.log(normalise('test') === normalise('sets'));

Output

true
false

Explanation: anagrams contain the same letters, so their sorted characters match.

const camel = 'loginButtonText';
const kebab = camel.replace(/([A-Z])/g, '-$1').toLowerCase();
console.log(kebab);

Output

login-button-text

Explanation: a regular expression inserts a dash before each capital letter, and lower-casing finishes the job.

const words = 'Playwright makes cross browser testing reliable'.split(' ');
let longest = '';
for (const w of words) if (w.length > longest.length) longest = w;
console.log(longest, longest.length);

Output

Playwright 10

Explanation: track the best word while looping, replacing it only when a longer one appears.

const truncate = (text, max) => (text.length > max ? text.slice(0, max - 3) + '...' : text);
console.log(truncate('Short title', 20));
console.log(truncate('A very long product name that overflows', 20));

Output

Short title
A very long produ...

Explanation: UI tests often check that long names are cut off, so knowing the exact rule helps.

const a = 'Submit', b = 'SUBMIT';
console.log(a === b);
console.log(a.toLowerCase() === b.toLowerCase());
console.log(a.localeCompare(b, undefined, { sensitivity: 'accent' }) === 0);

Output

false
true
true

Explanation: normalising case, or localeCompare with a sensitivity option, ignores letter case.

const pattern = /^[^\s@]+@[^\s@]+\.[a-z]{2,}$/i;
for (const email of ['qa@example.com', 'qa@example', 'qa example@test.com', 'QA@Shop.IN']) {
  console.log(email.padEnd(20), pattern.test(email) ? 'valid' : 'invalid');
}

Output

qa@example.com       valid
qa@example           invalid
qa example@test.com  invalid
QA@Shop.IN           valid

Explanation: a regular expression describes the allowed format. padEnd aligns the output in columns.

const confirmation = 'Thank you! Your order ORD-58213 has been placed.';
const match = confirmation.match(/ORD-\d+/);
console.log(match ? match[0] : 'Not found');

Output

ORD-58213

Explanation: match returns the matched text, so tests can reuse dynamic values shown in the UI.

const card = '4111 1111 1111 1234';
const digits = card.replace(/\s/g, '');
const masked = '**** **** **** ' + digits.slice(-4);
console.log(masked);

Output

**** **** **** 1234

Explanation: remove spaces first so the last four characters are always digits.

const title = '  Playwright: Getting Started (2026)!  ';
const slug = title.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
console.log(slug);

Output

playwright-getting-started-2026

Explanation: replace every run of non-alphanumeric characters with one dash, then trim dashes from the ends.

const cookieText = 'session=abc123; theme=dark; lang=en';
const cookies = {};
for (const part of cookieText.split('; ')) {
  const [key, value] = part.split('=');
  cookies[key] = value;
}
console.log(cookies);

Output

{ session: 'abc123', theme: 'dark', lang: 'en' }

Explanation: split into pairs, then split each pair at =.

const uiText = '  Total:\n   ₹1,299  ';
const normalised = uiText.replace(/\s+/g, ' ').trim();
console.log(normalised);

Output

Total: ₹1,299

Explanation: page text often contains line breaks and indentation. Playwright’s toHaveText normalises whitespace the same way.

const url = new URL('https://shop.test/search?q=wireless%20mouse&page=2');
console.log(url.pathname);
console.log(url.searchParams.get('q'));
console.log(url.searchParams.get('page'));

Output

/search
wireless mouse
2

Explanation: the URL class parses URLs and decodes values such as %20, which is safer than slicing strings.

const name = 'Checkout';
const passed = 18, failed = 2;
const report = `Suite: ${name}
Passed: ${passed}
Failed: ${failed}
Status: ${failed === 0 ? 'GREEN' : 'RED'}`;
console.log(report);

Output

Suite: Checkout
Passed: 18
Failed: 2
Status: RED

Explanation: template literals keep line breaks and can include expressions such as ternaries.

function firstDiff(a, b) {
  const len = Math.max(a.length, b.length);
  for (let i = 0; i < len; i++) if (a[i] !== b[i]) return i;
  return -1;
}
const expected = 'Welcome back, Asha';
const actual = 'Welcome back, Asha!';
const i = firstDiff(expected, actual);
console.log(i === -1 ? 'Texts match' : `Differs at index ${i}: '${expected[i] ?? ''}' vs '${actual[i] ?? ''}'`);

Output

Differs at index 18: '' vs '!'

Explanation: pinpointing the first difference makes text-assertion failures much quicker to debug.

const post = 'Learning #Playwright with #TypeScript for #QA automation';
const tags = post.match(/#\w+/g) || [];
console.log(tags.join(', '));
console.log(tags.length);

Output

#Playwright, #TypeScript, #QA
3

Explanation: the g flag returns every match. || [] avoids errors when nothing matches.

const raw = '  ASHA   sharma ';
const display = raw
  .trim()
  .split(/\s+/)
  .map(part => part[0].toUpperCase() + part.slice(1).toLowerCase())
  .join(' ');
console.log(display);

Output

Asha Sharma

Explanation: splitting on \s+ handles any number of spaces between words.

const review = '  Great product,   fast delivery and   very good packaging  ';
const wordCount = review.trim().split(/\s+/).length;
console.log('Words:', wordCount);
console.log(wordCount >= 10 ? 'Accepted' : 'Too short');

Output

Words: 8
Too short

Explanation: trimming first avoids empty strings at the ends being counted as words.