Regular Expressions — Text Ki Super Talaash

Code examples

Example 1 — test(): checking a Pakistani mobile number and an email

const mobilePattern = /^03\d{9}$/;
const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

console.log(mobilePattern.test("03001234567"));
console.log(mobilePattern.test("0300123"));
console.log(mobilePattern.test("04001234567"));

console.log(emailPattern.test("ali@example.com"));
console.log(emailPattern.test("ali.example.com"));
console.log(emailPattern.test("ali@example"));

What it does: The mobile pattern reads piece by piece: ^ start, then the letters 03 exactly, then \d{9} — exactly 9 more digits — then $ end. Total: an 11-digit number starting with 03, and nothing else allowed. The email pattern asks for: one or more non-space, non-@ characters, an @, one or more non-space, non-@ characters, a real dot \., and one or more non-space, non-@ characters — a simple email shape, checked by test, which answers only true or false.

What you will see: six lines in the console, in this order: true (03001234567 fits: 03 plus 9 digits), false (0300123 is too short), false (04001234567 has the right length but the wrong start), true (ali@example.com fits the email shape), false (ali.example.com has no @), false (ali@example has an @ but no dot after it). This is validation — the shape police from Lessons 3.15 and 3.23, now with a pattern instead of ten if checks.

Example 2 — match(): pulling every number out of a sentence

const sentence = "Ali scored 85, Sara scored 92 and Bilal scored 78";

const allNumbers = sentence.match(/\d+/g);
console.log(allNumbers);

const firstNumber = sentence.match(/\d+/);
console.log(firstNumber[0]);

const firstWordWithA = sentence.match(/[A][a-z]+/);
console.log(firstWordWithA[0]);

console.log("Has a 3-digit number? " + /\d{3}/.test(sentence));

What it does: \d+ means one or more digits in a row — a whole number, however long. With the g flag, match collects every number in the sentence into an array. Without g, the same pattern returns details about only the first find, and [0] takes the matched piece itself. The third search uses a class pattern: [A] then [a-z]+ — a capital A followed by one or more small letters, the shape of a name starting with A. The last line reuses test with {3} to ask if any 3-digit number exists at all.

What you will see: four results in the console, in order. First: [ '85', '92', '78' ] — all three scores, as strings (regex finds text, so numbers come out as text; use Number(...) if you need to calculate with them). Second: 85 — only the first number, because there is no g flag. Third: Ali — the first word matching the capital-A shape. Fourth: Has a 3-digit number? false — 85, 92 and 78 are all 2 digits, so no 3-digit shape exists in the sentence.

Example 3 — replace(): cleaning messy text

const messy = "Hello   world    this  is   JavaScript";
const clean = messy.replace(/\s+/g, " ");
console.log(clean);

const sentence = "Order 45 costs 1200 rupees and order 46 costs 950 rupees";
const hidden = sentence.replace(/\d+/g, "X");
console.log(hidden);

const code = "abc123def";
const onlyDigits = code.replace(/\D/g, "");
console.log(onlyDigits);
const onlyLetters = code.replace(/\d/g, "");
console.log(onlyLetters);

What it does: \s+ means one or more space characters in a row — every ugly gap in the messy line, long or short. Replacing each gap with a single " " (with the g flag, so every gap is fixed) collapses the spacing into clean text. The second replace hides every number as X. The third pair shows the negated class at work: \D matches every non-digit, so replacing those with nothing leaves only the digits; replacing every digit with nothing leaves only the letters.

What you will see: four lines in the console, in order: Hello world this is JavaScript — every gap now exactly one space. Then: Order X costs X rupees and order X costs X rupees — all four numbers hidden. Then: 123 — only the digits survived the \D cleanup. Then: abcdef — only the letters survived the digit cleanup. Same tool, three jobs: tidy, hide, extract.