`RegExp` na Bagay

Ipinaliwanag ng artikulong ito ang RegExp na bagay.

Ipapaliwanag namin ang RegExp na bagay gamit ang mga praktikal na halimbawa.

YouTube Video

RegExp na Bagay

Ano ang RegExp?

Ang RegExp (Regular Expression) ay isang bagay na ginagamit para katawanin ang mga pattern ng string. Hindi tulad ng simpleng paghahambing ng mga karakter, maaari mong i-define nang flexible ang mga 'string na tumutugon sa tiyak na kondisyon.'.

Sa pamamagitan ng paggamit ng RegExp object, maaari kang magsagawa ng mga operasyon gaya ng paghahanap, pag-validate, pagkuha, at pagpapalit ng mga string nang maikli at malinaw. Ito ay napaka-epektibo para sa mga pang-araw-araw na gawain gaya ng pagpapatunay ng mga input sa form, pagsusuri ng log, at pag-format ng teksto. Narito sa ibaba ang ilang simpleng halimbawa ng regular expressions.

1const pattern = /abc/;

• Tinitingnan ng regular expression na ito kung ang pagkakasunod-sunod na 'abc' ay kasama.

Paano Gumawa ng Regular Expressions (Dalawang Paraan)

Mayroong dalawang uri ng RegExp syntax: literal na notasyon at constructor notation.

1// Literal notation: pattern and flags are written together
2const literal         = /hello/;
3const literalWithFlag = /hello/i;
4const literalDigits   = /\d+/;
5
6// Constructor notation: pattern and flags are passed separately
7const constructor         = new RegExp("hello");
8const constructorWithFlag = new RegExp("hello", "i");
9const constructorDigits   = new RegExp("\\d+");

• Ang literal notation ay maigsi at madaling basahin, kaya angkop ito para sa mga regular expression na ginagamit bilang constants.. Sa kabilang banda, ang constructor notation ay ginagamit kapag gusto mong buuin ang pattern gamit ang mga variable o tukuyin ang nilalaman nito habang tumatakbo ang program.
• Sa literal notation, maaari mong mailarawan nang magkakasama at intuitively ang regular expression at ang mga flags nito. Sa kabilang banda, gamit ang constructor notation, kailangan mong tukuyin nang hiwalay ang pattern at ang mga flag.
• Dagdag pa rito, sa constructor notation, ipinapasa mo ang regular expression bilang string kaya ang mga backslash ay kailangang i-escape ng dalawang beses.

test(): Ang Pinakapayak na Pag-validate

Ang RegExp object ay naglalaan ng mga pamamaraan para sa pagsusuri at pagpapatakbo gamit ang regular expressions. Ang test() ay isang pamamaraan na nagbabalik ng boolean kung tumutugma ang pattern o hindi.

1const regex = /JavaScript/;
2
3console.log(regex.test("I love JavaScript")); // true
4console.log(regex.test("I love TypeScript")); // false

• Ito ang unang pamamaraan na dapat mong matutunan, at mainam ito para sa conditional branching o input validation.

match(): Kunin ang Mga Tumutugmang Resulta

Ang match() ay nagbabalik ng array na may taglay na tumutugmang string at detalyadong impormasyon.

1const text = "Version 1.2.3";
2const result = text.match(/\d+\.\d+\.\d+/);
3
4console.log(result[0]); // "1.2.3"

• Ang match() ay mas maginhawa kaysa sa test() para sa pagkuha at pag-parse ng datos.

replace(): Pagpapalit gamit ang Regular Expression

Ang replace() ay pumapalit sa tumugmang bahagi ng ibang string.

1const text = "Hello   World";
2const result = text.replace(/\s+/g, " ");
3
4console.log(result); // "Hello World"

• Maaari mo itong gamitin para sa pag-format ng log o pag-normalize ng mga hindi kailangang whitespace.

Panimulang Kaalaman sa Flags (g, i, m)

Maaari kang magtakda ng 'flags' sa regular expressions. Ang mga flag ay mga opsyon na kumokontrol kung paano nagpoproseso ng string ang isang regular expression ayon sa tiyak na mga patakaran. Kahit na pareho ang pattern, maaaring mag-iba ang resulta depende sa mga flag.

1const text = "apple Apple APPLE";
2const regex = /apple/gi;        // or new RegExp("apple", "gi");
3
4console.log(text.match(regex)); // ["apple", "Apple", "APPLE"]

• Ang g (global) flag ay naghahanap sa kabuuan ng string.
• Ang i (ignore case) flag ay hindi pinapansin ang pagkakaiba ng malaki at maliit na letra sa paghahambing.

1const multilineText = `apple
2banana
3apple`;
4
5const regexM = /^apple/gm;
6
7console.log(multilineText.match(regexM)); // ["apple", "apple"]

• Ang m (multiline) flag ay ginagamit upang ang mga multi-line na string ay ituring bawat linya. Sa ganitong paraan, ang ^ at $ ay gumagana batay sa simula o dulo ng bawat linya, hindi lamang sa buong string.

Mga Klase ng Karakter: Pinagsama-samang Maraming Kandidato

Sa paggamit ng-square brackets [], maaari kang magtakda ng set ng mga posibleng karakter sa isang posisyon.

1const regex = /gr[ae]y/;
2
3console.log(regex.test("gray")); // true
4console.log(regex.test("grey")); // true

• Kapaki-pakinabang ito para sa pagtanggap ng mga pagkakaiba sa pagbabaybay at simpleng alternatibo.

Metacharacters: Karaniwang Shortcut

Ang mga metacharacter ay mga simbolo na nagpapahintulot sa iyo na isulat ang mga karaniwang ginagamit na pattern sa mas pinaikling anyo.

1const regex = /\d{4}-\d{2}-\d{2}/;  // or new RegExp("\\d{4}-\\d{2}-\\d{2}");
2
3console.log(regex.test("2025-12-29")); // true

• Ang \d ay tumutukoy sa digit, at ang {n} ay tumutukoy sa bilang ng pag-uulit.

^ at $: I-validate ang Buong String

Ang ^ at $ ay nagsasaad ng simula at dulo ng isang string.

1const regex = /^\d+$/;
2
3console.log(regex.test("123"));   // true
4console.log(regex.test("123a"));  // false

• Mahalaga ang mga ito kapag kailangan ng eksaktong tugma, tulad ng sa input ng mga form.

Pag-group at Pagkuha

Sa paggamit ng panaklong (), maaari kang kumuha ng bahagi ng halaga.

1const text = "2025/12/29";
2const regex = /(\d{4})\/(\d{2})\/(\d{2})/;
3const [, year, month, day] = text.match(regex);
4
5console.log(year, month, day); // 2025 12 29

• Madalas itong gamitin sa paghahati ng petsa at mga structured na string.

Karaniwang Pagkakamali at Mga Dapat Tandaan

Ang regular expression ay makapangyarihan, ngunit maaari itong maging mahirap basahin.

1// Hard to read
2const regex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+$/;

• Kung ito ay maging masyadong kumplikado, maaari mong isaalang-alang ang pagdagdag ng mga komento, paghati ng mga expression, o pagrebisa mismo ng proseso.

Buod

Ang RegExp ay isang mahalagang pangunahing katangian sa JavaScript para sa madaling at eksaktong paglarawan ng pagpoproseso ng string. Hindi mo kailangang matutunan agad ang mahihirap na regular expression; mas mahalaga na gamit ang mga pangunahing pamamaraan at syntax gaya ng test, match, at replace ayon sa iyong mga praktikal na pangangailangan. Kung ituturing mong hindi 'espesyal na kaalaman' ang regular expression kundi 'kasangkapan para sa mas maayos na pattern', mapapabuti mo nang husto ang kalidad at kababasahan ng input validation at text processing.

Maaari mong sundan ang artikulo sa itaas gamit ang Visual Studio Code sa aming YouTube channel. Paki-check din ang aming YouTube channel.

YouTube Video