§

પૅટર્ન

ફ્લૅગ્સ
§

ટેસ્ટ string

§

મૅચ

0 મૅચ

    No matches — pattern test string enter.

    §

    રિપ્લેસ મોડ

    ઝડપી સંદર્ભ

    કૅરેક્ટર ક્લાસ

    \d
    Any digit, [0-9] equivalent.
    \w
    Any word character — letters, digits, underscore.
    \s
    Any whitespace — space, tab, newline.

    એન્કર

    \b
    Word boundary zero-width assertion.
    ^
    Input start (or each line when m flag).
    $
    Input end (or each line when m flag).

    ક્વૉન્ટિફાયર

    *
    Zero or more previous token, greedy.
    +
    One or more previous token, greedy.
    ?
    Zero or one previous token — or preceding quantifier lazy.
    {n,m}
    n to m repetitions previous token.

    ગ્રૂપ

    (...)
    Capturing group — $1, $2 replacements.
    (?:...)
    Non-capturing group — slot not consume.
    (?...)
    Named capturing group — $ replacements.

    Lookaround

    (?=...)
    Positive lookahead — followed by match.
    (?!...)
    Negative lookahead — NOT followed by match.
    (?<=...)
    Positive lookbehind — preceded by match.
    (?
    Negative lookbehind — NOT preceded by match.

    Escapes

    \\
    Literal backslash.
    \.
    Literal dot — metacharacter escape.

    JavaScript regular expressions ભારતીય developer daily: Husky pre-commit hooks commit message conventions, Shopify Magento SKU formats validate, AWS Athena Apache log parse, React form input sanitise. Aadhaar format, GSTIN validate, Indian phone numbers regex. Browser RegExp engine production same, test here ship.

    // સંબંધિત સાધનો

    ./url-encoder
    URL એન્કોડર
    URL માં સુરક્ષિત પરિવહન માટે સ્ટ્રિંગને percent-encode કરો.
    →
    ./json-formatter
    JSON ફૉર્મૅટર
    તમારા બ્રાઉઝરમાં JSON ફૉર્મૅટ, માન્ય, અને minify કરો.
    →
    ./base64-encoder
    Base64 એન્કોડર
    ટેક્સ્ટ અને ફાઇલ Base64 ફોર્મેટમાં એન્કોડ કરો.
    →
    ./
    બધા સાધનો
    Ultim8Soft નાં ઑનલાઇન સાધનોનો સંપૂર્ણ સંગ્રહ જુઓ.
    →

    તમારા બ્રાઉઝરમાં regex કેવી રીતે કામ કરે છે?

    દરેક JavaScript રનટાઇમ એક નેટિવ રેગ્યુલર એક્સપ્રેશન એન્જિન સાથે આવે છે — new RegExp(pattern, flags) તમારો પૅટર્ન કમ્પાઇલ કરે છે, પછી String.prototype.match, String.prototype.replace, અને RegExp.prototype.exec જેવી મેથડ તેને કોઈપણ ઇનપુટ સ્ટ્રિંગ સામે ચલાવે છે. આ ટેસ્ટર એ એન્જિનને એક UI માં લપેટે છે જેથી તમે બ્રાઉઝર છોડ્યા વગર પૅટર્ન એડિટ, રન અને ઇન્સ્પેક્ટ કરી શકો. તમે જે કંઈ ટાઇપ કરો છો — પૅટર્ન, ફ્લૅગ્સ, ટેસ્ટ સ્ટ્રિંગ, કે રિપ્લેસમેન્ટ — તેમાંથી કંઈ પણ નેટવર્ક પર મોકલવામાં આવતું નથી.

    regex ટેસ્ટર કેવી રીતે કામ કરે છે?

    પાઇપલાઇન થોડાંક ટૂંકાં પગલાંની છે, જે બધાં દરેક કીસ્ટ્રોક પર ક્લાયન્ટ-સાઇડ ચાલે છે (ટાઇપિંગ સરળ રહે તે માટે 150 ms નું debounce):

    1. તમારા પૅટર્નનું બૉડી ઉપરના ઇનપુટમાંથી વંચાય છે (શરૂઆતે કે અંતે કોઈ / ડિલિમિટર નહીં — એ સુશોભન માટે છે). પસંદ કરેલી ફ્લૅગ પિલ્સ gi કે gimsuy જેવી ફ્લૅગ સ્ટ્રિંગમાં જોડાય છે.
    2. new RegExp(patternBody, flags) પૅટર્ન કમ્પાઇલ કરે છે. જો એન્જિન SyntaxError થ્રો કરે (દા.ત. અમેળ કૌંસ કે અમાન્ય એસ્કેપ), તો સંદેશ ટેસ્ટ સ્ટ્રિંગની ઉપર રજૂ થાય છે અને મૅચ સૂચિ સાફ થઈ જાય છે. કમ્પાઇલ ભૂલ V8 / SpiderMonkey / JavaScriptCore નો અસલી err.message છે, એટલે જે તમે DevTools માં જોશો એ જ સાથે મેળ ખાય છે.
    3. મૅચ સૂચિ માટે, ટેસ્ટર હંમેશાં એક કૃત્રિમ ગ્લોબલ ફ્લૅગ સાથે ગણતરી કરે છે — એટલે ભલે તમે g બંધ કરી દો, સૂચિ હજુ પણ દરેક મૅચ બતાવે છે. પ્રમાણભૂત શૂન્ય-પહોળાઈ-મૅચ ગાર્ડ (if (m.index === rx.lastIndex) rx.lastIndex++) લૂપને ખાલી સ્ટ્રિંગ સાથે મૅચ થતા પૅટર્ન પર ઘૂમતો રહેવાથી રોકે છે. Replace મોડ તમારા અસલી ફ્લૅગ સેટને માન આપે છે જેથી $& String.prototype.replace ની જેમ જ વર્તે.
    4. દરેક પુનરાવર્તન વચ્ચે ટેસ્ટર performance.now() - start તપાસે છે અને 50 ms વીતી ગયા પછી અટકાવી દે છે. આ (a+)+$ જેવા ઇનપુટ સામે a ની લાંબી હારમાળા પર કૅટૅસ્ટ્રોફિક બૅકટ્રૅકિંગથી રક્ષણ આપે છે — નહીંતર ટૅબ હૅંગ થઈ જાય. આ ગાર્ડ બેસ્ટ-એફર્ટ છે: એક રોગવાળો સિંગલ-મૅચ પૅટર્ન હજુ પણ એક exec કૉલની અંદર સમય ખાઈ શકે છે. જો એવું ક્યારેય થાય, તો ટૅબ રિફ્રેશ કરો અને પૅટર્નને નૉન-ગ્રીડી ક્વૉન્ટિફાયર કે એટૉમિક-શૈલીના પોઝેસિવ (દા.ત. [^x]*x) સાથે ફરી લખો.
    5. ટેસ્ટ સ્ટ્રિંગ દરેક મૅચની રેન્જ પર સેગમેન્ટ્સમાં વહેંચાય છે અને મૅચ થયેલા સેગમેન્ટ્સ <mark class="rx-match rx-cap-N"> એલિમેન્ટમાં લપેટાય છે, જ્યાં N છ પૅલેટ રંગોમાંથી ચક્ર ફેરવે છે જેથી નજીકના મૅચ એક નજરમાં અલગ પાડવા સહેલા રહે. દરેક મૅચના ક્રમાંકિત ગ્રુપ (m[1], m[2], …) અને નામવાળા ગ્રુપ (m.groups) નીચે લેબલવાળી પંક્તિઓ તરીકે રજૂ થાય છે; જો d ફ્લૅગ સેટ હોય, તો પ્રતિ-ગ્રુપ [start, end] ઇન્ડેક્સ પણ બતાવાય છે.

    આ regex ટેસ્ટર શા માટે વાપરવું?

    • ગોપનીયતા: દરેક પૅટર્ન, ટેસ્ટ સ્ટ્રિંગ અને રિપ્લેસમેન્ટ તમારા બ્રાઉઝરમાં બિલ્ટ-ઇન JavaScript RegExp એન્જિન વાપરીને ચાલે છે. કંઈ પણ ટૅબમાંથી બહાર જતું નથી — જ્યારે ઇનપુટ કોઈ ગ્રાહક લૉગ, લીક થયેલ ઓળખપત્ર પૅટર્ન, કે એવી કોઈ વસ્તુ હોય જેને તમે હોસ્ટેડ SaaS regex પ્લેગ્રાઉન્ડમાં પેસ્ટ ન કરો, ત્યારે આ મહત્ત્વનું છે.
    • પ્રામાણિક ફ્લેવર: ટેસ્ટર ઠીક એ જ regex એન્જિન ઉઘાડું પાડે છે જેને Node.js, Chrome, Safari, Firefox, અને દરેક બ્રાઉઝર-આધારિત ફૉર્મ વૅલિડેટર ચલાવે છે. સૂક્ષ્મ તફાવતો છુપાવનારી કોઈ Perl-ફ્લેવર અનુવાદ સ્તર નથી — જે અહીં કામ કરે છે એ તમારા કોડમાં પણ કામ કરે છે.
    • કૅપ્ચર અને નામવાળા-ગ્રુપની ડિબગિંગ: દરેક ક્રમાંકિત ગ્રુપ ($1, $2, …) અને નામવાળો ગ્રુપ ($<year>) પ્રતિ મૅચ બતાવાય છે જેથી તમે એક પાર્સર બનાવી શકો અને સ્લૉટ્સ અનુમાન વગર પાછા વાંચી શકો. Replace મોડ તમને ગ્રુપ્સ મુક્તપણે ભેળવવા દે છે — $2-$1 પ્રથમ બે સ્લૉટ્સ સ્વૅપ કરે છે, $<name> નામવાળો સ્લૉટ અંદર મૂકે છે, અને $& સમગ્ર મૅચને પડઘો પાડે છે.
    • કૅટૅસ્ટ્રોફિક-બૅકટ્રૅકિંગ ગાર્ડ: ગણતરી પર 50 ms ની ટોચમર્યાદા (a+)+$ જેવા રોગવાળા પૅટર્નને ટૅબ ફ્રીઝ કરે તે પહેલાં અટકાવી દે છે. હૅંગ થયેલા બ્રાઉઝરની જગ્યાએ તમે એક સમજાવનારી ભૂલ જુઓ છો, અને પેજ તરત જ ઠીક થઈ જાય છે.

    regex ટેસ્ટરના સામાન્ય ઉપયોગો કયા છે?

    રેગ્યુલર એક્સપ્રેશન વેબ ડેવલપમેન્ટ, સુરક્ષા અને ડેટા કાર્ય દરમ્યાન દેખાય છે — આ ટેસ્ટર સૌથી સામાન્ય ઉપયોગના કિસ્સાઓને લક્ષ્ય બનાવે છે:

    • ફૉર્મ વૅલિડેશન: કોઈ ઈમેઇલ, ફોન, કે પોસ્ટલ-કોડ પૅટર્નનો પ્રોટોટાઇપ બનાવો, ટેસ્ટ સ્ટ્રિંગમાં નમૂના ઇનપુટ પેસ્ટ કરો, અને પૅટર્નને પ્રોડક્શન કોડમાં મોકલતા પહેલાં ખાતરી કરો કે દરેક પૉઝિટિવ કેસ મૅચ થાય છે અને દરેક નેગેટિવ કેસ થતો નથી.
    • લૉગ સ્ક્રૅપિંગ: NGINX, ઍપ્લિકેશન, કે ઑડિટ-લૉગ આઉટપુટનો એક ખંડ પેસ્ટ કરો, તમને રસ હોય તેવા ભાગો માટે નામવાળા ગ્રુપ્સ સાથે પૅટર્ન લખો ((?<ip>…) (?<path>…)), અને દરેક મૅચ પર કૅપ્ચર થયેલા સ્લૉટ્સ વાંચીને ખાતરી કરો કે તમારો પાર્સર સાચો છે.
    • રિફૅક્ટર સર્ચ-એન્ડ-રિપ્લેસ: કોઈ સ્નિપેટમાં ઓળખકર્તાઓ ફરી લખવા Replace મોડ વાપરો — (\w+)\.set(\w+)\( → $1.$2 = ગેટર કૉલ્સને પ્રૉપર્ટી અસાઇનમેન્ટમાં બદલે છે, અને લાઇવ પ્રીવ્યૂ તેને કોડમૉડમાં કમિટ કરતા પહેલાં પરિણામ બતાવે છે.

    Regex example?

    પૅટર્ન (\d{4})-(\d{2})-(\d{2}) ને g ફ્લૅગ સાથે લો, ટેસ્ટ સ્ટ્રિંગ release 2025-11-15, prerelease 2026-05-25 સામે ચલાવો. એન્જિન બે મૅચ શોધે છે. પ્રથમ મૅચ 2025-11-15 છે જેમાં ગ્રુપ 1 = 2025, ગ્રુપ 2 = 11, ગ્રુપ 3 = 15. બીજો મૅચ 2026-05-25 છે, એ જ ગ્રુપ આકાર સાથે. Replace મોડમાં, રિપ્લેસમેન્ટ ટેમ્પ્લેટ $3/$2/$1 બંને તારીખોને 15/11/2025 અને 25/05/2026 માં ફરી લખે છે — એક-પૅટર્ન ISO-થી-DMY રૂપાંતર જેને તમે પૅટર્નને કોઈ સ્ક્રિપ્ટમાં જોડતા પહેલાં દૃષ્ટિએ ચકાસી શકો.

    કોઈપણ regex કાર્ય માટે — પૅટર્ન બનાવવા, ડિબગ કરવા, કે ફરી લખવા — આ ટેસ્ટરને ઝડપી માર્ગ તરીકે વાપરો. બધું સ્થાનિક રીતે ચાલે છે; કંઈ પણ લૉગ થતું નથી; regex એન્જિન એ જ છે જે તમારું બ્રાઉઝર સાથે આવે છે, એટલે વર્તન રનટાઇમ પર પ્રોડક્શન કોડ જે જોશે એની સાથે મેળ ખાય છે.