Regex അല്ലെങ്കിൽ പതിവ് ഭാവങ്ങൾതുടക്കക്കാർക്ക് ഭയാനകമാണ്, എന്നാൽ ഏതൊരു പ്രോഗ്രാമർക്കും അത് ആവശ്യമാണ്. ജാവാസ്ക്രിപ്റ്റ് ഉപയോഗിച്ച് 5 ലളിതമായ ഉദാഹരണങ്ങൾ ഉപയോഗിച്ച് റെഗുലർ എക്സ്പ്രഷനുകൾ മനസ്സിലാക്കാം.

നിങ്ങൾക്ക് ഒരു പ്രശ്‌നമുണ്ടെങ്കിൽ, അത് സാധാരണ പദപ്രയോഗങ്ങളിലൂടെ പരിഹരിക്കാൻ പോകുകയാണെങ്കിൽ, നിങ്ങൾക്ക് ഇപ്പോൾ രണ്ട് പ്രശ്‌നങ്ങളുണ്ട്. എന്നൊരു ചൊല്ലുണ്ട്. കോഡിൽ കാണപ്പെടുന്ന പതിവ് പദപ്രയോഗങ്ങൾ ചിലപ്പോൾ പരിചിതമല്ലാത്ത ആളുകളിൽ ഭയവും വെറുപ്പും ഉണ്ടാക്കുന്നു.

എന്നാൽ വാസ്തവത്തിൽ, ഏതൊരു റീജക്സും ഒരു വരിയിൽ മുഴുവൻ ഫംഗ്ഷന്റെയും പ്രശ്നം പരിഹരിക്കാൻ കഴിയുന്ന ഒരു ടെംപ്ലേറ്റ് എക്സ്പ്രഷൻ മാത്രമാണ്. എന്നിരുന്നാലും, ഒരു സാധാരണ പദപ്രയോഗം നിർമ്മിക്കുന്നതിന്, ഒരു തുടക്കക്കാരന് ആശയക്കുഴപ്പത്തിലാകാനും തെറ്റുകൾ വരുത്താനും കഴിയുന്ന ഒരു കൂട്ടം കർശനമായ നിയമങ്ങൾ നിങ്ങൾ കണക്കിലെടുക്കേണ്ടതുണ്ട്.

പൊരുത്തപ്പെടുന്ന കഥാപാത്രങ്ങൾ

ഏറ്റവും അടിസ്ഥാനപരമായ പതിവ് പദപ്രയോഗങ്ങൾ ഒറ്റ പ്രതീകങ്ങളുമായി പൊരുത്തപ്പെടുന്നവയാണ്. അവരുടെ നിയമങ്ങൾ ഇതാ:

1. ഒരു കാലഘട്ടം (.) ഏതെങ്കിലും പ്രതീകവുമായി പൊരുത്തപ്പെടുന്നു. നിങ്ങൾക്ക് ഒരു നിർദ്ദിഷ്ട പോയിന്റിനായി തിരയണമെങ്കിൽ, "\" പ്രതീകം (\.) ഉപയോഗിച്ച് നിങ്ങൾ അതിൽ നിന്ന് രക്ഷപ്പെടണം.

2. മുമ്പത്തെ പ്രതീകം ഓപ്ഷണൽ ആണെന്ന് ഒരു ചോദ്യചിഹ്നം (?) സൂചിപ്പിക്കുന്നു. ഒരു സ്‌ട്രിംഗിൽ തന്നെ ചോദ്യചിഹ്നം തിരയുന്നതിന്, അത് "\" (\?) ഉപയോഗിച്ച് ഒഴിവാക്കണം.

var text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit lest. Donec convallis dignissim ligula, et rutrum est elat vistibulum eu."; // "elit" ഉം "elat" ഉം ചെയ്യും. ഡോട്ട് എന്നതിന്റെ അർത്ഥം ആരെങ്കിലും ചെയ്യുംചിഹ്നം. var regex = /el.t/g; console.log(text.match(regex)); // "est" ഉം "lest" ഉം ഒരുപോലെ നന്നായി പ്രവർത്തിക്കും. ചോദ്യചിഹ്നം "l" ഐച്ഛികമാക്കുന്നു. var regex2 = /l?est/g; console.log(text.match(regex2));

ഒന്നിലധികം പ്രതീകങ്ങൾ പൊരുത്തപ്പെടുത്തുക

പരാൻതീസിസിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന ഒന്നോ അതിലധികമോ പ്രതീകങ്ങളാണ് സെറ്റ്, ഉദാഹരണത്തിന് . അത്തരമൊരു പദപ്രയോഗം ഒരു സ്ട്രിംഗിലെ ഈ പ്രതീകങ്ങളുടെ കൂട്ടം മാത്രമേ തിരയൂ - ഇൻ ഈ ഉദാഹരണത്തിൽ a, b അല്ലെങ്കിൽ c മാത്രം. നേരെമറിച്ച്, "^" ചിഹ്നം ഉപയോഗിച്ചല്ലാതെ നിങ്ങൾക്ക് ഏതെങ്കിലും ചിഹ്നങ്ങളുടെ സംഭവങ്ങൾക്കായി തിരയാൻ കഴിയും. എ, ബി അല്ലെങ്കിൽ സി അല്ലാത്ത ഏത് പ്രതീകവും [^abc] പൊരുത്തപ്പെടും. നിങ്ങൾക്ക് പ്രതീകങ്ങളുടെയോ അക്കങ്ങളുടെയോ ഒരു ശ്രേണി വ്യക്തമാക്കാനും കഴിയും, ഉദാഹരണത്തിന് , .

സാധാരണ പദപ്രയോഗങ്ങൾ എഴുതുന്നത് എളുപ്പമാക്കുന്ന അന്തർനിർമ്മിത പ്രതീക സെറ്റുകൾ ഉണ്ട്. അവയെ ചുരുക്കെഴുത്ത് അല്ലെങ്കിൽ ചുരുക്കെഴുത്ത് എന്ന് വിളിക്കുന്നു. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് പകരം \D എഴുതാം. മറ്റ് പ്രതീകങ്ങൾക്ക് (നമ്പറുകളും അടിവരകളും ഉൾപ്പെടെ) - \w, \W, അതുപോലെ സ്‌പെയ്‌സുകൾക്കും - \s, \S എന്നിവയ്ക്ക് ചുരുക്കങ്ങളുണ്ട്.

// "കാറ്റ്" അല്ല "കാറ്റ്", "കാൻ" എന്നിവ മാത്രമേ പ്രവർത്തിക്കൂ. var ടെക്സ്റ്റ് = "പൂച്ച കാർ കഴിയും"; console.log(text.match(/ca/g)); // പൂച്ചയും ക്യാനും ഒഴികെ എല്ലാം കടന്നുപോകും (ഒരു ^ ചിഹ്നമുണ്ട്) console.log(text.match(/ca[^tn]/g)); // അക്കങ്ങൾ മാത്രം വാചകം നൽകുന്ന മറ്റൊരു ഉദാഹരണം = "എനിക്ക് 8 കപ്പ് കാപ്പി വേണം, ദയവായി."; console.log("എത്ര കപ്പുകൾ: " + text.match(//g)); // കുറുക്കുവഴി ഉപയോഗിക്കുന്നതിനുള്ള എളുപ്പവഴി \d console.log("എത്ര കപ്പുകൾ: " + text.match(/\d/g)); // കൺസോൾ.ലോഗ് (text.match(/\D/g)) എന്ന നമ്പറുകൾ ഒഴികെ എല്ലാം കടന്നുപോകുന്നു;

പൊരുത്തപ്പെടുന്ന വാക്കുകൾ

മിക്ക കേസുകളിലും നിങ്ങൾ മുഴുവൻ വാക്കുകളും തിരയേണ്ടതുണ്ട് വ്യക്തിഗത പ്രതീകങ്ങൾ. ഒരു പ്രതീകമോ പ്രതീകങ്ങളുടെ കൂട്ടമോ ആവർത്തിക്കുന്ന മോഡിഫയറുകൾ (+), (-) എന്നിവ ഉപയോഗിച്ചാണ് ഇത് ചെയ്യുന്നത്.

(X) ചേർക്കുന്നത് ആവർത്തനങ്ങളുടെ കൃത്യമായ എണ്ണം വ്യക്തമാക്കുന്നു, (x, y) - ശ്രേണി (x, y എന്നിവ സംഖ്യകളാണ്).

കൂടാതെ, വാക്കുകളുടെ അറ്റത്തുള്ള അതിരുകളുമായി പൊരുത്തപ്പെടുന്ന ഒരു പ്രത്യേക പാറ്റേൺ \b ഉണ്ട്.

var text = "ഹലോ 1974 ലെ ആളുകൾ. ഞാൻ ഭാവിയിൽ നിന്നാണ് വന്നത്. 2014 ൽ ഞങ്ങൾക്ക് ലേസർ തോക്കുകളും ഹോവർ ബോർഡുകളും ഉണ്ട്, ചന്ദ്രനിൽ ജീവിക്കും!"; // വർഷങ്ങൾ കണ്ടെത്തും. \d+ വർഷം ഒന്നോ അതിലധികമോ പ്രതീകങ്ങളുമായി പൊരുത്തപ്പെടുംRegex = /\d+/g; console.log("വർഷങ്ങൾ: ", text.match(yearRegex)); // എല്ലാ വാക്യങ്ങളും കണ്ടെത്തുന്നു. ഞങ്ങളുടെ ഓഫറുകൾ ആരംഭിക്കുന്നു വലിയ അക്ഷരം, ഒരു പീരിയഡ് അല്ലെങ്കിൽ ആശ്ചര്യചിഹ്നത്തിൽ അവസാനിക്കുന്നു. var വാക്യംRegex = /.+?(\.|!)/g; console.log("വാക്യങ്ങൾ: ", text.match(sentenceRegex)); // "h" ൽ ആരംഭിക്കുന്ന എല്ലാ വാക്കുകളും കണ്ടെത്തുന്നു. വലിയക്ഷരവും ചെറിയക്ഷരവും നമുക്ക് അനുയോജ്യമാണ്, അതിനാൽ അതിർത്തി എന്ന വാക്ക് നിർവചിക്കാൻ i // \b മോഡിഫയർ ഉപയോഗിക്കുന്നു. var hWords = /\bh\w+/ig; console.log("H Words: ", text.match(hWords)); // 4 മുതൽ 6 വരെയുള്ള എല്ലാ വാക്കുകളും കണ്ടെത്തുന്നു var findWords = /\b\w(4,6)\b/g; console.log("4 മുതൽ 6 അക്ഷരങ്ങൾക്കിടയിലുള്ള വാക്കുകൾ: ", text.match(findWords)); // 5 പ്രതീകങ്ങളേക്കാൾ നീളമുള്ള വാക്കുകൾ കണ്ടെത്തുക console.log("വാക്കുകൾ 5 അക്ഷരങ്ങളോ അതിൽ കൂടുതലോ: ", text.match(/\b\w(5,)\b/g)); // കൃത്യമായി 6 പ്രതീകങ്ങൾ നീളമുള്ള വാക്കുകൾ കണ്ടെത്തുന്നു console.log("കൃത്യമായി 6 അക്ഷരങ്ങൾ നീളമുള്ള വാക്കുകൾ: ", text.match(/\b\w(6)\b/g));

മുഴുവൻ സ്ട്രിംഗ് മൂല്യനിർണ്ണയം

JavaScript-ൽ, ടെക്സ്റ്റ് ഫീൽഡുകളിൽ നിന്നുള്ള ഉപയോക്തൃ ഇൻപുട്ട് സാധൂകരിക്കുന്നതിന് അത്തരം പദപ്രയോഗങ്ങൾ ഉപയോഗിക്കാം. സ്ട്രിംഗുകൾ സാധൂകരിക്കുന്നതിന്, ഈ ആവശ്യത്തിനായി ^ (വരിയുടെ ആരംഭം), $ (വരിയുടെ അവസാനം) എന്നീ പദപ്രയോഗങ്ങൾ ഉപയോഗിച്ച് ഒരു വാചക ശകലത്തിന്റെ തുടക്കത്തിലും അവസാനത്തിലും ബന്ധിപ്പിച്ചിരിക്കുന്ന ഒരു സാധാരണ പതിവ് പദപ്രയോഗം ഉപയോഗിക്കുന്നു. നിങ്ങൾ എഴുതുന്ന പാറ്റേൺ ടെക്‌സ്‌റ്റിന്റെ മുഴുവൻ നീളത്തിലും വ്യാപിച്ചുകിടക്കുന്നുവെന്നും അതിന്റെ ഭാഗവുമായി പൊരുത്തപ്പെടുന്നില്ലെന്നും ഈ ചിഹ്നങ്ങൾ ഉറപ്പാക്കുന്നു.

കൂടാതെ, ഈ സാഹചര്യത്തിൽ, ഞങ്ങൾ regex ഒബ്‌ജക്റ്റിന്റെ test() രീതി ഉപയോഗിക്കുന്നു, ഇത് പതിവ് എക്‌സ്‌പ്രഷൻ സ്‌ട്രിംഗുമായി പൊരുത്തപ്പെടുന്നുണ്ടോ എന്ന് പരിശോധിക്കുമ്പോൾ ശരിയോ തെറ്റോ നൽകുന്നു.

// ഞങ്ങൾക്ക് സ്ട്രിംഗുകളുടെ ഒരു നിരയുണ്ട്, നമുക്ക് ലിങ്കുകൾ കണ്ടെത്താം..com/", "123461", "https://site/?s=google", "http://സാധുവായ url അല്ല", "abc http: / /invalid.url/" ]; var regex = /^https?:\/\/[\w\/?.&-=]+$/; var urls = ; for(var i = 0; i< strings.length; i++){ if(regex.test(strings[i])){ // Валидная ссылка urls.push(strings[i]); } } console.log("Valid URLs: ", urls);

തിരയുകയും പകരം വയ്ക്കുകയും ചെയ്യുക

സാധാരണ പദപ്രയോഗങ്ങൾ ഉപയോഗിച്ച് എളുപ്പമാക്കുന്ന മറ്റൊരു പൊതു ജോലി ടെക്സ്റ്റ് കണ്ടെത്തി മാറ്റിസ്ഥാപിക്കുക എന്നതാണ്.

ചില ആളുകൾ, ഒരു പ്രശ്നം അഭിമുഖീകരിക്കുമ്പോൾ, ഇങ്ങനെ ചിന്തിക്കുന്നു: "ഓ, ഞാൻ പതിവ് പദപ്രയോഗങ്ങൾ ഉപയോഗിക്കും." ഇപ്പോൾ അവർക്ക് രണ്ട് പ്രശ്‌നങ്ങളുണ്ട്.
ജാമി സാവിൻസ്കി

യുവാൻ-മ പറഞ്ഞു, “വിറകിന് കുറുകെ മരം മുറിക്കാൻ വളരെയധികം ശക്തി ആവശ്യമാണ്. പ്രശ്ന ഘടനയിലുടനീളം പ്രോഗ്രാം ചെയ്യുന്നതിന് ധാരാളം കോഡ് ആവശ്യമാണ്.
മാസ്റ്റർ യുവാൻ-മാ, "ബുക്ക് ഓഫ് പ്രോഗ്രാമിംഗ്"

പ്രോഗ്രാമിംഗ് ടൂളുകളും ടെക്നിക്കുകളും താറുമാറായ പരിണാമപരമായ രീതിയിൽ നിലനിൽക്കുകയും വ്യാപിക്കുകയും ചെയ്യുന്നു. ചിലപ്പോൾ അതിജീവിക്കുന്നത് മനോഹരവും മിടുക്കനുമല്ല, മറിച്ച് അവരുടെ മേഖലയിൽ വേണ്ടത്ര നന്നായി പ്രവർത്തിക്കുന്നവയാണ് - ഉദാഹരണത്തിന്, അവ മറ്റൊരു വിജയകരമായ സാങ്കേതികവിദ്യയുമായി സംയോജിപ്പിച്ചാൽ.

ഈ അധ്യായത്തിൽ, അത്തരമൊരു ഉപകരണം ഞങ്ങൾ ചർച്ച ചെയ്യും - പതിവ് പദപ്രയോഗങ്ങൾ. സ്ട്രിംഗ് ഡാറ്റയിലെ പാറ്റേണുകൾ വിവരിക്കുന്നതിനുള്ള ഒരു മാർഗമാണിത്. അവർ ജാവാസ്ക്രിപ്റ്റിലും മറ്റ് നിരവധി ഭാഷകളിലും ടൂളുകളിലും ഉൾപ്പെടുത്തിയിരിക്കുന്ന ഒരു ചെറിയ, ഒറ്റപ്പെട്ട ഭാഷ സൃഷ്ടിക്കുന്നു.

പതിവ് ഷെഡ്യൂളുകൾ വളരെ വിചിത്രവും വളരെ ഉപയോഗപ്രദവുമാണ്. അവരുടെ വാക്യഘടന നിഗൂഢവും അവരുടെ ജാവാസ്ക്രിപ്റ്റ് പ്രോഗ്രാമിംഗ് ഇന്റർഫേസ് വൃത്തികെട്ടതുമാണ്. പക്ഷേ ഇത് ശക്തമായ ഉപകരണംസ്ട്രിംഗുകൾ പര്യവേക്ഷണം ചെയ്യുന്നതിനും പ്രോസസ്സ് ചെയ്യുന്നതിനും. നിങ്ങൾ അവ മനസ്സിലാക്കിക്കഴിഞ്ഞാൽ, നിങ്ങൾ കൂടുതൽ ഫലപ്രദമായ ഒരു പ്രോഗ്രാമറായി മാറും.

ഒരു സാധാരണ പദപ്രയോഗം സൃഷ്ടിക്കുന്നു

Var re1 = പുതിയ RegExp("abc"); var re2 = /abc/;

ഈ രണ്ട് പതിവ് പദപ്രയോഗങ്ങളും ഒരേ പാറ്റേണിനെ പ്രതിനിധീകരിക്കുന്നു: "a" എന്ന പ്രതീകവും തുടർന്ന് "b" എന്ന അക്ഷരവും തുടർന്ന് "c" എന്ന പ്രതീകവും.

നിങ്ങൾ RegExp കൺസ്ട്രക്റ്റർ ഉപയോഗിക്കുകയാണെങ്കിൽ, പാറ്റേൺ ഇങ്ങനെ എഴുതിയിരിക്കുന്നു സാധാരണ സ്ട്രിംഗ്, അതിനാൽ ബാക്ക്സ്ലാഷുകളെ സംബന്ധിച്ച എല്ലാ നിയമങ്ങളും ബാധകമാണ്.

സ്ലാഷുകൾക്കിടയിൽ പാറ്റേൺ ഉള്ള രണ്ടാമത്തെ എൻട്രി, ബാക്ക്സ്ലാഷുകളെ വ്യത്യസ്തമായി പരിഗണിക്കുന്നു. ഒന്നാമതായി, പാറ്റേൺ ഒരു ഫോർവേഡ് സ്ലാഷിൽ അവസാനിക്കുന്നതിനാൽ, നിങ്ങൾ ഇടേണ്ടതുണ്ട് ബാക്ക്സ്ലാഷ്ഫോർവേഡ് സ്ലാഷിന് മുമ്പ് ഞങ്ങളുടെ പാറ്റേണിൽ ഉൾപ്പെടുത്താൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു. കൂടാതെ, ഭാഗമല്ലാത്ത ബാക്ക്സ്ലാഷുകൾ പ്രത്യേക കഥാപാത്രങ്ങൾതരം \n സംരക്ഷിക്കപ്പെടും (അവഗണിക്കുന്നതിനുപകരം, സ്ട്രിംഗുകളിലെന്നപോലെ), കൂടാതെ പാറ്റേണിന്റെ അർത്ഥം മാറ്റുകയും ചെയ്യും. ചോദ്യചിഹ്നം അല്ലെങ്കിൽ പ്ലസ് പോലുള്ള ചില പ്രതീകങ്ങൾക്ക് പതിവ് പദപ്രയോഗങ്ങളിൽ ഒരു പ്രത്യേക അർത്ഥമുണ്ട്, നിങ്ങൾക്ക് അത്തരമൊരു പ്രതീകം കണ്ടെത്തണമെങ്കിൽ, അതിന് മുമ്പായി ഒരു ബാക്ക്സ്ലാഷ് ഉണ്ടായിരിക്കണം.

Var8teenPlus = /പതിനെട്ട്\+/;

ഏത് പ്രതീകങ്ങൾക്ക് മുമ്പായി ഒരു സ്ലാഷ് നൽകണമെന്ന് അറിയാൻ, പതിവ് എക്സ്പ്രഷനുകളിലെ എല്ലാ പ്രത്യേക പ്രതീകങ്ങളുടെയും ഒരു ലിസ്റ്റ് നിങ്ങൾ പഠിക്കേണ്ടതുണ്ട്. ഇത് ഇതുവരെ സാധ്യമല്ല, അതിനാൽ സംശയമുണ്ടെങ്കിൽ, അക്ഷരമോ അക്കമോ സ്ഥലമോ അല്ലാത്ത ഏതെങ്കിലും പ്രതീകത്തിന് മുന്നിൽ ഒരു ബാക്ക്സ്ലാഷ് ഇടുക.

പൊരുത്തങ്ങൾക്കായി പരിശോധിക്കുന്നു

Console.log(/abc/.test("abcde")); // → true console.log(/abc/.test("abxde")); // → തെറ്റ്

നോൺ-സ്പെഷ്യൽ പ്രതീകങ്ങൾ മാത്രം ഉൾക്കൊള്ളുന്ന ഒരു സാധാരണ ക്രമം ഈ പ്രതീകങ്ങളുടെ ഒരു ക്രമം മാത്രമാണ്. ഞങ്ങൾ പരീക്ഷിക്കുന്ന വരിയിൽ എബിസി എവിടെയെങ്കിലും ഉണ്ടെങ്കിൽ (തുടക്കത്തിൽ മാത്രമല്ല), ടെസ്റ്റ് ശരിയാകും.

ഒരു കൂട്ടം കഥാപാത്രങ്ങൾക്കായി തിരയുന്നു

നമുക്ക് ഏതെങ്കിലും നമ്പർ കണ്ടെത്തണം എന്ന് പറയാം. നമ്മൾ ഒരു കൂട്ടം പ്രതീകങ്ങൾ ചതുര ബ്രാക്കറ്റുകളിൽ റെഗുലർ എക്സ്പ്രഷനിൽ ഇടുമ്പോൾ, ആ പദപ്രയോഗം ബ്രാക്കറ്റിലെ ഏതെങ്കിലും പ്രതീകങ്ങളുമായി പൊരുത്തപ്പെടുന്നു എന്നാണ് അർത്ഥമാക്കുന്നത്.

രണ്ട് പദപ്രയോഗങ്ങളും ഒരു നമ്പർ അടങ്ങിയ വരികളിലാണ്.

Console.log(//.test("1992-ൽ")); // → true console.log(//.test("1992-ൽ")); // → ശരിയാണ്

സ്ക്വയർ ബ്രാക്കറ്റുകളിൽ, രണ്ട് പ്രതീകങ്ങൾക്കിടയിലുള്ള ഒരു ഡാഷ് പ്രതീകങ്ങളുടെ ഒരു ശ്രേണി വ്യക്തമാക്കാൻ ഉപയോഗിക്കുന്നു, അവിടെ യൂണികോഡ് എൻകോഡിംഗ് വഴിയാണ് ക്രമം വ്യക്തമാക്കുന്നത്. 0 മുതൽ 9 വരെയുള്ള പ്രതീകങ്ങൾ ഒരു നിരയിൽ മാത്രമാണുള്ളത് (48 മുതൽ 57 വരെയുള്ള കോഡുകൾ), അതിനാൽ അവയെല്ലാം പിടിച്ചെടുക്കുകയും ഏത് സംഖ്യയുമായി പൊരുത്തപ്പെടുകയും ചെയ്യുന്നു.

നിരവധി പ്രതീക ഗ്രൂപ്പുകൾക്ക് അവരുടേതായ ബിൽറ്റ്-ഇൻ ചുരുക്കരൂപങ്ങളുണ്ട്.

\d ഏതെങ്കിലും നമ്പർ
\w ആൽഫാന്യൂമെറിക് പ്രതീകം
\s വൈറ്റ്‌സ്‌പേസ് പ്രതീകം (സ്‌പേസ്, ടാബ്, ന്യൂലൈൻ മുതലായവ)
\D ഒരു സംഖ്യയല്ല
\W ഒരു ആൽഫാന്യൂമെറിക് പ്രതീകമല്ല
\S ഒരു വൈറ്റ്‌സ്‌പേസ് പ്രതീകമല്ല
. ലൈൻ ഫീഡ് ഒഴികെയുള്ള ഏതെങ്കിലും പ്രതീകം

അതിനാൽ, നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന എക്സ്പ്രഷൻ ഉപയോഗിച്ച് 01/30/2003 15:20 പോലെ തീയതിയും സമയ ഫോർമാറ്റും സജ്ജമാക്കാൻ കഴിയും:

Var തീയതിസമയം = /\d\d-\d\d-\d\d\d\d \d\d:\d\d/; console.log(dateTime.test("30-01-2003 15:20")); // → true console.log(dateTime.test("30-Jan-2003 15:20")); // → തെറ്റ്

ഭയങ്കരമായി തോന്നുന്നു, അല്ലേ? വളരെയധികം ബാക്ക്‌സ്ലാഷുകൾ ഉണ്ട്, ഇത് പാറ്റേൺ മനസ്സിലാക്കാൻ ബുദ്ധിമുട്ടാണ്. ഞങ്ങൾ അത് പിന്നീട് അൽപ്പം മെച്ചപ്പെടുത്തും.

ചതുര ബ്രാക്കറ്റുകളിലും ബാക്ക്സ്ലാഷുകൾ ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, [\d.] എന്നാൽ ഏതെങ്കിലും സംഖ്യ അല്ലെങ്കിൽ കാലയളവ് എന്നാണ് അർത്ഥമാക്കുന്നത്. സ്ക്വയർ ബ്രാക്കറ്റിനുള്ളിലെ കാലയളവ് അതിന്റെ പ്രത്യേക അർത്ഥം നഷ്ടപ്പെടുകയും ഒരു കാലഘട്ടമായി മാറുകയും ചെയ്യുന്നത് ശ്രദ്ധിക്കുക. + പോലുള്ള മറ്റ് പ്രത്യേക പ്രതീകങ്ങൾക്കും ഇത് ബാധകമാണ്.

നിങ്ങൾക്ക് ഒരു കൂട്ടം പ്രതീകങ്ങൾ വിപരീതമാക്കാം - അതായത്, സെറ്റിലുള്ളവ ഒഴികെയുള്ള ഏതെങ്കിലും പ്രതീകം നിങ്ങൾ കണ്ടെത്തേണ്ടതുണ്ടെന്ന് പറയുക - തുറക്കുന്ന ചതുര ബ്രാക്കറ്റിന് തൊട്ടുപിന്നാലെ ഒരു ^ ചിഹ്നം സ്ഥാപിക്കുക.

Var notBinary = /[^01]/; console.log(notBinary.test("1100100010100110")); // → false console.log(notBinary.test("1100100010200110")); // → ശരിയാണ്

ടെംപ്ലേറ്റിന്റെ ആവർത്തിച്ചുള്ള ഭാഗങ്ങൾ

പതിവ് ക്രമത്തിൽ എന്തെങ്കിലും ശേഷം + ചിഹ്നം ഇടുകയാണെങ്കിൽ, ഈ ഘടകം ഒന്നിലധികം തവണ ആവർത്തിക്കാം എന്നാണ് ഇതിനർത്ഥം. /\d+/ എന്നാൽ ഒന്നോ അതിലധികമോ അക്കങ്ങൾ എന്നാണ് അർത്ഥമാക്കുന്നത്.

Console.log(/"\d+"/.test(""123"")); // → true console.log(/"\d+"/.test("""")); // → false console.log(/"\d*"/.test(""123"")); // → true console.log(/"\d*"/.test("""")); // → ശരിയാണ്

നക്ഷത്രചിഹ്നത്തിന് * ഏതാണ്ട് ഒരേ അർത്ഥമുണ്ട്, പക്ഷേ ഇത് പൂജ്യം തവണ സംഭവിക്കാൻ പാറ്റേൺ അനുവദിക്കുന്നു. എന്തെങ്കിലും ഒരു നക്ഷത്രചിഹ്നം പിന്തുടരുകയാണെങ്കിൽ, അത് ഒരിക്കലും പാറ്റേണിനെ വരിയിലാകുന്നതിൽ നിന്ന് തടയില്ല - അത് പൂജ്യം തവണ മാത്രമേ ദൃശ്യമാകൂ.

ഒരു ചോദ്യചിഹ്നം പാറ്റേണിന്റെ ഭാഗത്തെ ഓപ്ഷണൽ ആക്കുന്നു, അതായത് പൂജ്യം അല്ലെങ്കിൽ ഒരിക്കൽ സംഭവിക്കാം. ഇനിപ്പറയുന്ന ഉദാഹരണത്തിൽ, u എന്ന പ്രതീകം ദൃശ്യമാകാം, പക്ഷേ പാറ്റേൺ അല്ലാത്തപ്പോഴും പൊരുത്തപ്പെടുന്നു.

Var അയൽക്കാരൻ = /neighbou?r/; console.log(neighbour.test("neighbour")); // → true console.log(neighbor.test("neighbour")); // → ശരിയാണ്

ഒരു പാറ്റേൺ എത്ര തവണ സംഭവിക്കണം എന്ന് കൃത്യമായി വ്യക്തമാക്കാൻ, ഉപയോഗിക്കുക ബ്രേസുകൾ. (4) ഒരു മൂലകത്തിന് ശേഷം അത് വരിയിൽ 4 തവണ പ്രത്യക്ഷപ്പെടണം എന്നാണ്. നിങ്ങൾക്ക് ഒരു വിടവ് വ്യക്തമാക്കാനും കഴിയും: (2,4) എന്നതിനർത്ഥം മൂലകം കുറഞ്ഞത് 2 തവണയും 4 തവണയിൽ കൂടരുത് എന്നാണ്.

ഒന്നോ രണ്ടോ അക്കങ്ങളുടെ ദിവസങ്ങളും മാസങ്ങളും മണിക്കൂറുകളും അനുവദനീയമായ തീയതിയുടെയും സമയ ഫോർമാറ്റിന്റെയും മറ്റൊരു പതിപ്പ്. കൂടാതെ ഇത് കുറച്ചുകൂടി വായിക്കാവുന്നതുമാണ്.

Var തീയതിസമയം = /\d(1,2)-\d(1,2)-\d(4) \d(1,2):\d(2)/; console.log(dateTime.test("30-1-2003 8:45")); // → ശരിയാണ്

അക്കങ്ങളിൽ ഒന്ന് ഒഴിവാക്കിക്കൊണ്ട് നിങ്ങൾക്ക് ഓപ്പൺ-എൻഡ് സ്പെയ്സുകൾ ഉപയോഗിക്കാം. (,5,) പാറ്റേൺ പൂജ്യം മുതൽ അഞ്ച് തവണ വരെ സംഭവിക്കാം എന്നാണ് അർത്ഥമാക്കുന്നത്, (5,) എന്നാൽ അഞ്ചോ അതിലധികമോ തവണ.

സബ് എക്സ്പ്രഷനുകൾ ഗ്രൂപ്പുചെയ്യുന്നു

Var cartoonCrying = /boo+(hoo+)+/i; console.log(cartoonCrying.test("Boohooooohooooo")); // → ശരിയാണ്

ആദ്യത്തെയും രണ്ടാമത്തെയും പ്ലസ് ബൂ, ഹൂ എന്നിവയിലെ രണ്ടാമത്തെ ഒയ്ക്ക് മാത്രമേ ബാധകമാകൂ. മൂന്നാമത്തെ + എന്നത് മുഴുവൻ ഗ്രൂപ്പിനെയും (ഹൂ+) സൂചിപ്പിക്കുന്നു, ഇത് ഒന്നോ അതിലധികമോ സീക്വൻസുകൾ കണ്ടെത്തുന്നു.

പദപ്രയോഗത്തിന്റെ അവസാനത്തിലുള്ള i എന്ന അക്ഷരം പതിവ് പദപ്രയോഗത്തെ കേസ്-ഇൻസെൻസിറ്റീവ് ആക്കുന്നു - അങ്ങനെ B-യുമായി പൊരുത്തപ്പെടുന്നു.

മത്സരങ്ങളും ഗ്രൂപ്പുകളും

Var പൊരുത്തം = /\d+/.exec("ഒന്ന് രണ്ട് 100"); console.log(match); // → ["100"] console.log(match.index); // → 8

എക്‌സിക് നൽകിയ ഒബ്‌ജക്റ്റിന് ഒരു സൂചിക പ്രോപ്പർട്ടി ഉണ്ട്, അതിൽ പൊരുത്തമുണ്ടായ പ്രതീകത്തിന്റെ എണ്ണം അടങ്ങിയിരിക്കുന്നു. പൊതുവേ, ഒബ്‌ജക്റ്റ് സ്ട്രിംഗുകളുടെ ഒരു നിര പോലെയാണ് കാണപ്പെടുന്നത്, ഇവിടെ ഒരു പൊരുത്തത്തിനായി പരിശോധിച്ച സ്ട്രിംഗാണ് ആദ്യ ഘടകം. ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, ഞങ്ങൾ തിരയുന്ന സംഖ്യകളുടെ ക്രമം ഇതായിരിക്കും.

സ്ട്രിംഗുകൾക്ക് സമാനമായ രീതിയിൽ പ്രവർത്തിക്കുന്ന ഒരു പൊരുത്ത രീതിയുണ്ട്.

Console.log("ഒന്ന് രണ്ട് 100".match(/\d+/)); // → ["100"]

ഒരു റെഗുലർ എക്‌സ്‌പ്രഷനിൽ പരാൻതീസിസുകളാൽ ഗ്രൂപ്പുചെയ്‌ത ഉപവിഷ്‌കാരങ്ങൾ അടങ്ങിയിരിക്കുമ്പോൾ, ഈ ഗ്രൂപ്പുകളുമായി പൊരുത്തപ്പെടുന്ന വാചകവും അറേയിൽ ദൃശ്യമാകും. ആദ്യ ഘടകം എല്ലായ്പ്പോഴും ഒരു സമ്പൂർണ്ണ പൊരുത്തമാണ്. രണ്ടാമത്തേത് ആദ്യ ഗ്രൂപ്പുമായി പൊരുത്തപ്പെടുന്ന ഭാഗമാണ് (ആദ്യം പരാൻതീസിസ് ഉണ്ടായത്), തുടർന്ന് രണ്ടാമത്തെ ഗ്രൂപ്പും മറ്റും.

Var quotedText = /"([^"]*)"/; console.log(quotedText.exec("അവൾ പറഞ്ഞു "ഹലോ"")); // → [""ഹലോ"", "ഹലോ"]

ഒരു ഗ്രൂപ്പിനെ കണ്ടെത്താനാകാത്തപ്പോൾ (ഉദാഹരണത്തിന്, ഒരു ചോദ്യചിഹ്നത്തിന് ശേഷം), അറേയിലെ അതിന്റെ സ്ഥാനം നിർവചിക്കപ്പെട്ടിട്ടില്ല. ഒരു ഗ്രൂപ്പ് പലതവണ മത്സരിച്ചാൽ, അവസാന മത്സരം മാത്രമേ അറേയിൽ ഉണ്ടാകൂ.

Console.log(/bad(ly)?/.exec("മോശം")); // → ["മോശം", നിർവചിക്കാത്തത്] console.log(/(\d)+/.exec("123")); // → ["123", "3"]

സ്ട്രിംഗുകളുടെ ഭാഗങ്ങൾ വീണ്ടെടുക്കാൻ ഗ്രൂപ്പുകൾ ഉപയോഗപ്രദമാണ്. ഒരു സ്ട്രിംഗിന് ഒരു തീയതി ഉണ്ടോ എന്ന് പരിശോധിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നില്ലെങ്കിൽ, അത് എക്‌സ്‌ട്രാക്‌റ്റ് ചെയ്‌ത് തീയതിയെ പ്രതിനിധീകരിക്കുന്ന ഒരു ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കുക, നമുക്ക് പരാൻതീസിസിൽ സംഖ്യകളുടെ ക്രമം ഉൾപ്പെടുത്തുകയും എക്‌സിക് ഫലത്തിൽ നിന്ന് തീയതി തിരഞ്ഞെടുക്കുകയും ചെയ്യാം.

എന്നാൽ ആദ്യം, ജാവാസ്ക്രിപ്റ്റിൽ തീയതിയും സമയവും സംഭരിക്കുന്നതിനുള്ള മുൻഗണനാ മാർഗം പഠിക്കുന്ന ഒരു ചെറിയ വ്യതിചലനം.

തീയതി തരം

Console.log(പുതിയ തീയതി()); // → സൺ നവംബർ 09 2014 00:07:57 GMT+0300 (CET)

നിങ്ങൾക്ക് ഒരു നിശ്ചിത സമയം ഉൾക്കൊള്ളുന്ന ഒരു ഒബ്ജക്റ്റ് സൃഷ്ടിക്കാനും കഴിയും

Console.log(പുതിയ തീയതി(2015, 9, 21)); // → ഒക്ടോബർ 21 2015 00:00:00 GMT+0300 (CET) console.log(പുതിയ തീയതി(2009, 11, 9, 12, 59, 59, 999)); // → 2009 ഡിസംബർ 09 12:59:59 GMT+0300 (CET)

മാസ സംഖ്യകൾ പൂജ്യത്തിലും ദിവസ സംഖ്യകൾ ഒന്നിലും ആരംഭിക്കുന്ന ഒരു കൺവെൻഷൻ JavaScript ഉപയോഗിക്കുന്നു. ഇത് മണ്ടത്തരവും പരിഹാസ്യവുമാണ്. ശ്രദ്ധാലുവായിരിക്കുക.

അവസാനത്തെ നാല് ആർഗ്യുമെന്റുകൾ (മണിക്കൂർ, മിനിറ്റ്, സെക്കൻഡ്, മില്ലിസെക്കൻഡ്) ഓപ്‌ഷണൽ ആണ്, നഷ്‌ടപ്പെട്ടാൽ പൂജ്യമായി സജ്ജീകരിക്കും.

1970-ന്റെ തുടക്കം മുതൽ കടന്നുപോയ മില്ലിസെക്കൻഡുകളുടെ എണ്ണമായാണ് ടൈംസ്റ്റാമ്പുകൾ സംഭരിച്ചിരിക്കുന്നത്. 1970-ന് മുമ്പുള്ള സമയങ്ങളിൽ, നെഗറ്റീവ് നമ്പറുകൾ ഉപയോഗിച്ചിരുന്നു (ഇത് അക്കാലത്ത് സൃഷ്ടിക്കപ്പെട്ട യുണിക്സ് സമയ കൺവെൻഷൻ മൂലമാണ്). തീയതി ഒബ്‌ജക്റ്റിന്റെ getTime രീതി ഈ നമ്പർ നൽകുന്നു. ഇത് സ്വാഭാവികമായും വലുതാണ്.
console.log(പുതിയ തീയതി(2013, 11, 19).getTime()); // → 1387407600000 console.log(പുതിയ തീയതി(1387407600000)); // → വ്യാഴം 19 ഡിസംബർ 2013 00:00:00 GMT+0100 (CET)

നിങ്ങൾ തീയതി കൺസ്ട്രക്റ്ററിന് ഒരു ആർഗ്യുമെന്റ് നൽകിയാൽ, അത് ഈ മില്ലിസെക്കൻഡുകളായി കണക്കാക്കും. ഒരു തീയതി ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിച്ച് getTime രീതിയിലൂടെയോ Date.now ഫംഗ്‌ഷനിലേക്ക് വിളിച്ചോ നിങ്ങൾക്ക് നിലവിലെ മില്ലിസെക്കൻഡ് മൂല്യം ലഭിക്കും.

തീയതി ഒബ്‌ജക്റ്റിന് അതിന്റെ ഘടകങ്ങൾ വീണ്ടെടുക്കുന്നതിന് getFullYear, getMonth, getDate, getHours, getMinutes, getSeconds എന്നീ രീതികളുണ്ട്. 93 അല്ലെങ്കിൽ 14 പോലെയുള്ള ഉപയോഗശൂന്യമായ രണ്ടക്ക കോഡ് നൽകുന്ന ഒരു getYear രീതിയും ഉണ്ട്.

ടെംപ്ലേറ്റിന്റെ പ്രസക്ത ഭാഗങ്ങൾ പരാൻതീസിസിൽ ഉൾപ്പെടുത്തുന്നതിലൂടെ, നമുക്ക് സ്ട്രിംഗിൽ നിന്ന് നേരിട്ട് ഒരു തീയതി ഒബ്ജക്റ്റ് സൃഷ്ടിക്കാൻ കഴിയും.

ഫംഗ്‌ഷൻ ഫൈൻഡ്‌ഡേറ്റ്(സ്ട്രിംഗ്) ( var dateTime = /(\d(1,2))-(\d(1,2))-(\d(4))/; var match = dateTime.exec(string); മടങ്ങുക പുതിയ തീയതി(നമ്പർ(പൊരുത്തം), നമ്പർ(പൊരുത്തം) - 1, നമ്പർ(മാച്ച്)); ) console.log(findDate("30-1-2003")); // → 2003 ജനുവരി 30 00:00:00 GMT+0100 (CET)

വാക്കിന്റെയും വരിയുടെയും അതിരുകൾ

മുഴുവൻ സ്ട്രിംഗും എടുക്കാൻ നമുക്ക് മാച്ച് നിർബന്ധിക്കണമെങ്കിൽ, ഞങ്ങൾ ^, $ ടാഗുകൾ ഉപയോഗിക്കുന്നു. ^ വരിയുടെ തുടക്കവുമായി പൊരുത്തപ്പെടുന്നു, $ അവസാനവുമായി പൊരുത്തപ്പെടുന്നു. അതിനാൽ /^\d+$/ ഒന്നോ അതിലധികമോ അക്കങ്ങൾ മാത്രമുള്ള ഒരു സ്‌ട്രിംഗുമായി പൊരുത്തപ്പെടുന്നു, /^!/ ആരംഭിക്കുന്ന ഒരു സ്‌ട്രിംഗുമായി പൊരുത്തപ്പെടുന്നു ആശ്ചര്യചിഹ്നം, കൂടാതെ /x^/ ഒരു വരിയുമായി പൊരുത്തപ്പെടുന്നില്ല (വരിയുടെ തുടക്കത്തിന് മുമ്പ് ഒരു x ഉണ്ടാകരുത്).

നേരെമറിച്ച്, തീയതി ആരംഭിക്കുന്നതും അവസാനിക്കുന്നതും ഒരു പദ അതിർത്തിയിൽ ആണെന്ന് ഉറപ്പാക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, ഞങ്ങൾ \b അടയാളം ഉപയോഗിക്കുന്നു. ഒരു പദത്തിന്റെ അതിർത്തി ഒരു വരിയുടെ തുടക്കമോ അവസാനമോ ആകാം, അല്ലെങ്കിൽ ഒരു വരിയിൽ ഒരു വശത്ത് ആൽഫാന്യൂമെറിക് പ്രതീകം \w ഉള്ളതും മറുവശത്ത് ആൽഫാന്യൂമെറിക് അല്ലാത്ത പ്രതീകവുമുള്ള ഏത് സ്ഥലവും ആകാം.

Console.log(/cat/.test("concatenate")); // → true console.log(/\bcat\b/.test("concatenate")); // → തെറ്റ്

അതിർത്തി ലേബൽ ഒരു ചിഹ്നമല്ല എന്നത് ശ്രദ്ധിക്കുക. ഇത് കേവലം ഒരു നിയന്ത്രണമാണ്, അതായത് ഒരു നിശ്ചിത വ്യവസ്ഥ പാലിക്കുകയാണെങ്കിൽ മാത്രമേ ഒരു പൊരുത്തം സംഭവിക്കുകയുള്ളൂ.

തിരഞ്ഞെടുക്കൽ ഉള്ള ടെംപ്ലേറ്റുകൾ

മൂന്ന് റെഗുലർ എക്സ്പ്രെഷനുകൾ എഴുതാനും അവ ഓരോന്നായി പരിശോധിക്കാനും കഴിയും, പക്ഷേ ഒരു മികച്ച മാർഗമുണ്ട്. ചിഹ്നം | അതിന്റെ ഇടത്തോട്ടും വലത്തോട്ടും ഉള്ള പാറ്റേണുകൾ തമ്മിലുള്ള ഒരു തിരഞ്ഞെടുപ്പിനെ സൂചിപ്പിക്കുന്നു. കൂടാതെ നമുക്ക് ഇനിപ്പറയുന്നവ പറയാം:

മൃഗങ്ങളുടെ എണ്ണം = /\b\d+ (പന്നി|പശു|കോഴി)?\b/; console.log(animalCount.test("15 പന്നികൾ")); // → true console.log(animalCount.test("15 pigchickens")); // → തെറ്റ്

പ്രയോഗിച്ച പാറ്റേണിന്റെ ഭാഗത്തെ പരാൻതീസിസ് ഡിലിമിറ്റ് ചെയ്യുന്നു, കൂടാതെ രണ്ടിൽ കൂടുതൽ ഓപ്‌ഷനുകളിൽ നിന്ന് ഒരു ചോയ്‌സ് സൂചിപ്പിക്കാൻ അത്തരം നിരവധി ഓപ്പറേറ്റർമാരെ ഒന്നിനുപുറകെ ഒന്നായി സ്ഥാപിക്കാവുന്നതാണ്.

തിരയല് യന്ത്രം

ഡയഗ്രാമിന്റെ ഇടതുവശത്ത് നിന്ന് വലത്തോട്ട് ഒരു പാത കണ്ടെത്താൻ കഴിയുമെങ്കിൽ ഒരു പദപ്രയോഗം ഒരു സ്‌ട്രിംഗുമായി പൊരുത്തപ്പെടുന്നു. ഞങ്ങൾ ഓർക്കുന്നു നിലവിലെ സ്ഥാനംഒരു വരിയിൽ, ഓരോ തവണയും നമ്മൾ ദീർഘചതുരത്തിലൂടെ പോകുമ്പോൾ, വരിയുടെ ഭാഗം നമ്മുടെ സ്ഥാനത്തിന് തൊട്ടുപിന്നാലെ ദീർഘചതുരത്തിന്റെ ഉള്ളടക്കവുമായി പൊരുത്തപ്പെടുന്നുണ്ടോയെന്ന് ഞങ്ങൾ പരിശോധിക്കുന്നു.

ഫ്ലോചാർട്ടിലൂടെ പോകുമ്പോൾ "3 പന്നികൾ" എന്ന സ്ട്രിംഗിലെ ഞങ്ങളുടെ പതിവ് പ്രതീകത്തിന്റെ പൊരുത്തം പരിശോധിക്കുന്നത് ഇതുപോലെയാണ് എന്നാണ് ഇതിനർത്ഥം:

4-ാം സ്ഥാനത്ത് ഒരു പദ അതിർത്തിയുണ്ട്, ഞങ്ങൾ ആദ്യത്തെ ദീർഘചതുരം കടന്നുപോകുന്നു
- 4-ആം സ്ഥാനത്ത് നിന്ന് ഞങ്ങൾ നമ്പർ കണ്ടെത്തി രണ്ടാമത്തെ ദീർഘചതുരത്തിലൂടെ കടന്നുപോകുന്നു
- 5-ാം സ്ഥാനത്ത്, രണ്ടാമത്തെ ദീർഘചതുരത്തിന് മുന്നിൽ ഒരു പാത തിരികെ അടയ്ക്കുന്നു, രണ്ടാമത്തേത് ദീർഘചതുരത്തിലേക്ക് ഒരു സ്പെയ്സുമായി പോകുന്നു. ഞങ്ങൾക്ക് ഒരു സ്പെയ്സുണ്ട്, ഒരു സംഖ്യയല്ല, ഞങ്ങൾ രണ്ടാമത്തെ പാത തിരഞ്ഞെടുക്കുന്നു.
- ഇപ്പോൾ ഞങ്ങൾ ആറാം സ്ഥാനത്താണ്, “പന്നികളുടെ” തുടക്കത്തിലും പാതകളുടെ ട്രിപ്പിൾ ബ്രാഞ്ചിംഗിലും. വരിയിൽ "പശു" അല്ലെങ്കിൽ "കോഴി" ഇല്ല, എന്നാൽ "പന്നി" ഉണ്ട്, അതിനാൽ ഞങ്ങൾ ഈ പാത തിരഞ്ഞെടുക്കുന്നു.
- ട്രിപ്പിൾ ഫോർക്കിന് ശേഷമുള്ള 9-ാം സ്ഥാനത്ത്, ഒരു പാത "s" ബൈപാസ് ചെയ്ത് അവസാന പദത്തിന്റെ അതിർത്തി ദീർഘചതുരത്തിലേക്ക് പോകുന്നു, രണ്ടാമത്തേത് "s" വഴി പോകുന്നു. ഞങ്ങൾക്ക് ഒരു "s" ഉണ്ട് അതിനാൽ ഞങ്ങൾ അവിടെ പോകുന്നു.
- 10-ാം സ്ഥാനത്ത് ഞങ്ങൾ വരിയുടെ അവസാനത്തിലാണ്, അതിർത്തി എന്ന വാക്കിന് മാത്രമേ പൊരുത്തപ്പെടാൻ കഴിയൂ. വരിയുടെ അവസാനം അതിർത്തിയായി കണക്കാക്കപ്പെടുന്നു, ഞങ്ങൾ അവസാന ദീർഘചതുരത്തിലൂടെ കടന്നുപോകുന്നു. ഇപ്പോൾ ഞങ്ങൾ ഞങ്ങളുടെ ടെംപ്ലേറ്റ് വിജയകരമായി കണ്ടെത്തി.

അടിസ്ഥാനപരമായി, പതിവ് എക്സ്പ്രഷനുകൾ പ്രവർത്തിക്കുന്ന രീതി, സ്ട്രിംഗിന്റെ തുടക്കത്തിൽ അൽഗോരിതം ആരംഭിക്കുകയും അവിടെ ഒരു പൊരുത്തം കണ്ടെത്താൻ ശ്രമിക്കുകയും ചെയ്യുന്നു എന്നതാണ്. ഞങ്ങളുടെ കാര്യത്തിൽ, ഒരു പദത്തിന്റെ അതിരുണ്ട്, അതിനാൽ അത് ആദ്യത്തെ ദീർഘചതുരം കടന്നുപോകുന്നു - പക്ഷേ അവിടെ ഒരു സംഖ്യയും ഇല്ല, അതിനാൽ അത് രണ്ടാമത്തെ ദീർഘചതുരത്തിൽ ഇടറിവീഴുന്നു. തുടർന്ന് അത് സ്ട്രിംഗിലെ രണ്ടാമത്തെ പ്രതീകത്തിലേക്ക് നീങ്ങുകയും അവിടെ ഒരു പൊരുത്തം കണ്ടെത്താൻ ശ്രമിക്കുകയും ചെയ്യുന്നു... അങ്ങനെ അത് ഒരു പൊരുത്തം കണ്ടെത്തുന്നത് വരെ അല്ലെങ്കിൽ സ്ട്രിംഗിന്റെ അവസാനത്തിൽ എത്തുന്നതുവരെ, ഈ സാഹചര്യത്തിൽ പൊരുത്തം കണ്ടെത്താനായില്ല.

കിക്ക്ബാക്കുകൾ

ഒരു പൊരുത്തത്തിനായി തിരയുമ്പോൾ, സ്ട്രിംഗിൽ അത്തരമൊരു സംഖ്യ ഇല്ലെങ്കിലും, അൽഗോരിതം ടോപ്പ് പാത്ത് (ബൈനറി നമ്പർ) എടുക്കുന്നത് സംഭവിക്കാം. ഉദാഹരണത്തിന്, "103" എന്ന വരി ഉണ്ടെങ്കിൽ, 3 എന്ന നമ്പറിൽ എത്തിയതിനുശേഷം മാത്രമേ അത് തെറ്റായ പാതയിലാണെന്ന് അൽഗോരിതം മനസ്സിലാക്കുകയുള്ളൂ എന്ന് വ്യക്തമാണ്. പൊതുവേ, ഈ ത്രെഡിലല്ല, സാധാരണ ക്രമവുമായി ലൈൻ പൊരുത്തപ്പെടുന്നു.

അപ്പോൾ അൽഗോരിതം തിരികെ പോകുന്നു. ഒരു നാൽക്കവലയിൽ, അത് നിലവിലെ സ്ഥാനം ഓർമ്മിക്കുന്നു (ഞങ്ങളുടെ കാര്യത്തിൽ, ഇത് വരിയുടെ തുടക്കമാണ്, അതിർത്തി എന്ന വാക്കിന് തൊട്ടുപിന്നാലെ) അതിനാൽ നിങ്ങൾക്ക് തിരികെ പോയി തിരഞ്ഞെടുത്തത് പ്രവർത്തിക്കുന്നില്ലെങ്കിൽ മറ്റൊരു പാത പരീക്ഷിക്കാം. "103" എന്ന സ്‌ട്രിങ്ങിന്, മൂന്നെണ്ണം കണ്ടുമുട്ടിയ ശേഷം, അത് തിരികെ പോയി ദശാംശ പാതയിലൂടെ പോകാൻ ശ്രമിക്കും. ഇത് പ്രവർത്തിക്കും, അതിനാൽ ഒരു പൊരുത്തം കണ്ടെത്തും.

ഒരു സമ്പൂർണ്ണ പൊരുത്തം കണ്ടെത്തിയാലുടൻ അൽഗോരിതം നിർത്തുന്നു. ഇതിനർത്ഥം, നിരവധി ഓപ്ഷനുകൾ അനുയോജ്യമാണെങ്കിലും, അവയിലൊന്ന് മാത്രമേ ഉപയോഗിക്കുന്നുള്ളൂ (അവ സാധാരണ ക്രമത്തിൽ ദൃശ്യമാകുന്ന ക്രമത്തിൽ).

+, * എന്നിവ പോലുള്ള ആവർത്തന ഓപ്പറേറ്ററുകൾ ഉപയോഗിക്കുമ്പോൾ ബാക്ക്‌ട്രാക്കിംഗ് സംഭവിക്കുന്നു. നിങ്ങൾ "abcxe" എന്ന സ്ട്രിംഗിൽ /^.*x/ എന്ന് തിരയുകയാണെങ്കിൽ, regex ഭാഗം.* മുഴുവൻ സ്ട്രിംഗും ഉപയോഗിക്കാൻ ശ്രമിക്കും. "x" കൂടി ആവശ്യമാണെന്ന് അപ്പോൾ അൽഗോരിതം മനസ്സിലാക്കും. സ്ട്രിംഗിന്റെ അവസാനത്തിന് ശേഷം “x” ഇല്ലാത്തതിനാൽ, ഒരു പ്രതീകം പിന്നിലേക്ക് നീക്കിക്കൊണ്ട് ഒരു പൊരുത്തം കണ്ടെത്താൻ അൽഗോരിതം ശ്രമിക്കും. abcx-ന് ശേഷം x ഇല്ല, തുടർന്ന് അത് വീണ്ടും abc എന്ന ഉപസ്‌ട്രിംഗിലേക്ക് റോൾ ചെയ്യുന്നു. വരിക്ക് ശേഷം, അത് x കണ്ടെത്തുകയും 0 മുതൽ 4 വരെയുള്ള സ്ഥാനങ്ങളിൽ ഒരു വിജയകരമായ പൊരുത്തം റിപ്പോർട്ട് ചെയ്യുകയും ചെയ്യുന്നു.

ഒന്നിലധികം റോൾബാക്കുകളിലേക്ക് നയിക്കുന്ന ഒരു പതിവ് ദിനചര്യ നിങ്ങൾക്ക് എഴുതാം. പാറ്റേൺ ഇൻപുട്ട് ഡാറ്റയുമായി ഒന്നിലധികം തവണ പൊരുത്തപ്പെടുത്തുമ്പോൾ ഈ പ്രശ്നം സംഭവിക്കുന്നു. വ്യത്യസ്ത വഴികൾ. ഉദാഹരണത്തിന്, ഒരു സാധാരണ പദപ്രയോഗം എഴുതുമ്പോൾ നമുക്ക് തെറ്റ് സംഭവിക്കുകയാണെങ്കിൽ ബൈനറി നമ്പറുകൾ, നമ്മൾ ആകസ്മികമായി /(+)+b/ പോലെ എന്തെങ്കിലും എഴുതിയേക്കാം.

അൽഗോരിതം 0സെക്കിന്റെയും 1സെന്റിന്റെയും നീണ്ട സ്ട്രിംഗിൽ അത്തരമൊരു പാറ്റേൺ തിരയുകയാണെങ്കിൽ, അവസാനം "ബി" ഇല്ലെങ്കിൽ, അക്കങ്ങൾ തീരുന്നത് വരെ അത് ആദ്യം അകത്തെ ലൂപ്പിലൂടെ കടന്നുപോകും. അവസാനം "ബി" ഇല്ലെന്ന് അവൻ ശ്രദ്ധിക്കും, അവൻ ഒരു സ്ഥാനം പിന്നോട്ട് പോകും, ​​പുറം ലൂപ്പിലൂടെ പോകും, ​​വീണ്ടും ഉപേക്ഷിക്കും, ആന്തരിക ലൂപ്പിലൂടെ മറ്റൊരു സ്ഥാനത്തേക്ക് മടങ്ങാൻ ശ്രമിക്കും ... അവൻ തുടരും. രണ്ട് ലൂപ്പുകളും ഉപയോഗിച്ച് ഈ രീതിയിൽ തിരയാൻ. അതായത്, വരിയുടെ ഓരോ പ്രതീകവുമായുള്ള ജോലിയുടെ അളവ് ഇരട്ടിയാകും. നിരവധി ഡസൻ പ്രതീകങ്ങൾക്ക് പോലും, ഒരു പൊരുത്തം കണ്ടെത്തുന്നതിന് വളരെ സമയമെടുക്കും.

പകരം രീതി

Console.log("ഡാഡ്".replace("p", "m")); // → മാപ്പ്

ആദ്യ ആർഗ്യുമെന്റ് ഒരു റെഗുലർ എക്‌സ്‌പ്രഷനും ആകാം, ഈ സാഹചര്യത്തിൽ വരിയിലെ പതിവ് എക്‌സ്‌പ്രഷന്റെ ആദ്യ സംഭവം മാറ്റിസ്ഥാപിക്കപ്പെടുന്നു. റെഗുലർ എക്സ്പ്രഷനിലേക്ക് “g” (ഗ്ലോബൽ) ഓപ്ഷൻ ചേർക്കുമ്പോൾ, ആദ്യത്തേത് മാത്രമല്ല, എല്ലാ സംഭവങ്ങളും മാറ്റിസ്ഥാപിക്കും

Console.log("Borobudur".replace(//, "a")); // → Barobudur console.log("Borobudur".replace(//g, "a")); // → ബരാബദർ

"എല്ലാം മാറ്റിസ്ഥാപിക്കുക" എന്ന ഓപ്‌ഷൻ ഒരു പ്രത്യേക ആർഗ്യുമെന്റിലൂടെയോ അല്ലെങ്കിൽ റീപ്ലേസ് ഓൾ പോലെയുള്ള ഒരു പ്രത്യേക രീതിയിലൂടെയോ കൈമാറുന്നത് അർത്ഥവത്താണ്. എന്നാൽ നിർഭാഗ്യവശാൽ, ഈ ഓപ്ഷൻ സാധാരണ സംവിധാനത്തിലൂടെ തന്നെ കൈമാറ്റം ചെയ്യപ്പെടുന്നു.

റെഗുലർ എക്‌സ്‌പ്രഷനിൽ വ്യക്തമാക്കിയ, ഒരു സ്‌ട്രിംഗിൽ കാണുന്ന ഗ്രൂപ്പുകളിലേക്കുള്ള ലിങ്കുകൾ ഉപയോഗിക്കുമ്പോൾ, റെഗുലർ എക്‌സ്‌പ്രഷനുകളുടെ പൂർണ്ണ ശക്തി വെളിപ്പെടും. ഉദാഹരണത്തിന്, "ലാസ്റ്റ് നെയിം, ഫസ്റ്റ് നെയിം" ഫോർമാറ്റിൽ ആളുകളുടെ പേരുകൾ, ഒരു വരിയിൽ ഒരു പേര് എന്നിങ്ങനെയുള്ള ഒരു വരി ഞങ്ങളുടെ പക്കലുണ്ട്. "ഫസ്റ്റ് നെയിം ലാസ്റ്റ് നെയിം" ലഭിക്കുന്നതിന് അവ സ്വാപ്പ് ചെയ്ത് കോമ നീക്കം ചെയ്യണമെങ്കിൽ ഞങ്ങൾ ഇനിപ്പറയുന്നവ എഴുതുന്നു:

Console.log("ഹോപ്പർ, ഗ്രേസ്\nMcCarthy, John\nRitchie, Dennis" .replace(/([\w ]+), ([\w ]+)/g, "$2 $1")); // → ഗ്രേസ് ഹോപ്പർ // ജോൺ മക്കാർത്തി // ഡെന്നിസ് റിച്ചി

റീപ്ലേസ്‌മെന്റ് ലൈനിലെ $1, $2 എന്നിവ പരാൻതീസിസിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന പ്രതീകങ്ങളുടെ ഗ്രൂപ്പുകളെ സൂചിപ്പിക്കുന്നു. $1 എന്നത് ആദ്യ ഗ്രൂപ്പുമായി പൊരുത്തപ്പെടുന്ന ടെക്‌സ്‌റ്റ് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു, രണ്ടാമത്തെ ഗ്രൂപ്പുമായി $2, അങ്ങനെ $9 വരെ. മുഴുവൻ പൊരുത്തവും $& വേരിയബിളിൽ അടങ്ങിയിരിക്കുന്നു.

രണ്ടാമത്തെ ആർഗ്യുമെന്റായി നിങ്ങൾക്ക് ഒരു ഫംഗ്‌ഷൻ കൈമാറാനും കഴിയും. ഓരോ മാറ്റിസ്ഥാപിക്കലിനും, ഒരു ഫംഗ്‌ഷനെ വിളിക്കും, അതിന്റെ ആർഗ്യുമെന്റുകൾ കണ്ടെത്തിയ ഗ്രൂപ്പുകളായിരിക്കും (ലൈനിന്റെ പൊരുത്തപ്പെടുന്ന ഭാഗം മുഴുവനും), അതിന്റെ ഫലം ഒരു പുതിയ വരിയിൽ ചേർക്കും.

ലളിതമായ ഉദാഹരണം:

Var s = "The cia and fbi"; console.log(s.replace(/\b(fbi|cia)\b/g, function(str) ( str.toUpperCase(); ))); // → സിഐഎയും എഫ്ബിഐയും

കൂടുതൽ രസകരമായ ഒന്ന് ഇതാ:

Var സ്റ്റോക്ക് = "1 നാരങ്ങ, 2 കാബേജ്, 101 മുട്ടകൾ"; ഫംഗ്ഷൻ minusOne(പൊരുത്തം, തുക, യൂണിറ്റ്) ( തുക = നമ്പർ(തുക) - 1; (തുക == 1) // ഒരെണ്ണം മാത്രം അവശേഷിക്കുന്നുണ്ടെങ്കിൽ, അവസാന യൂണിറ്റിലെ "s" നീക്കം ചെയ്യുക = unit.slice(0, unit. നീളം - 1); അല്ലെങ്കിൽ (തുക == 0) തുക = "ഇല്ല"; റിട്ടേൺ തുക + " " + യൂണിറ്റ്; ) console.log(stock.replace(/(\d+) (\w+)/g, minusOne) ); // → നാരങ്ങ, 1 കാബേജ്, 100 മുട്ടകൾ എന്നിവയില്ല

കോഡ് ഒരു സ്ട്രിംഗ് എടുക്കുന്നു, ഒരു വാക്ക് പിന്തുടരുന്ന സംഖ്യകളുടെ എല്ലാ സംഭവങ്ങളും കണ്ടെത്തുന്നു, കൂടാതെ ഓരോ സംഖ്യയും ഒന്ന് കുറച്ചുകൊണ്ട് ഒരു സ്ട്രിംഗ് നൽകുന്നു.

ഗ്രൂപ്പ് (\d+) തുകയുടെ ആർഗ്യുമെന്റിലേക്കും (\w+) യൂണിറ്റ് ആർഗ്യുമെന്റിലേക്കും പോകുന്നു. ഫംഗ്ഷൻ തുകയെ ഒരു സംഖ്യയാക്കി മാറ്റുന്നു - ഇത് എല്ലായ്പ്പോഴും പ്രവർത്തിക്കുന്നു, കാരണം ഞങ്ങളുടെ പാറ്റേൺ \d+ ആണ്. 1 ഇനം മാത്രമേ അവശേഷിക്കുന്നുള്ളൂവെങ്കിൽ, വാക്കിൽ മാറ്റങ്ങൾ വരുത്തുക.

അത്യാഗ്രഹം

ഫംഗ്ഷൻ സ്ട്രിപ്പ് കമന്റുകൾ(കോഡ്) ( റിട്ടേൺ കോഡ്.replace(/\/\/.*|\/\*[^]*\*\//g, ""); ) console.log(stripComments("1 + /* 2 */3")); // → 1 + 3 console.log(stripComments("x = 10;// പത്ത്!")); // → x = 10; console.log(stripComments("1 /* a */+/* b */ 1")); //→ 1 1

"അല്ലെങ്കിൽ" ഓപ്പറേറ്ററിന് മുമ്പുള്ള ഭാഗം രണ്ട് സ്ലാഷുകളുമായി പൊരുത്തപ്പെടുന്നു, തുടർന്ന് ന്യൂലൈനുകൾ ഒഴികെ എത്ര പ്രതീകങ്ങൾ വേണമെങ്കിലും. വൃത്തിയാക്കൽ ഭാഗം മൾട്ടിലൈൻ അഭിപ്രായങ്ങൾ, കൂടുതൽ സങ്കീർണ്ണമായ. ഞങ്ങൾ [^] ഉപയോഗിക്കുന്നു, അതായത്. ഏത് കഥാപാത്രത്തെയും കണ്ടെത്താനുള്ള ഒരു മാർഗമായി ശൂന്യമല്ലാത്ത ഏത് കഥാപാത്രവും. ബ്ലോക്ക് കമന്റുകൾ ഒരു പുതിയ ലൈനിൽ തുടരുന്നതിനാലും പുതിയ ലൈൻ പ്രതീകം കാലയളവുമായി പൊരുത്തപ്പെടാത്തതിനാലും ഞങ്ങൾക്ക് ഒരു പീരിയഡ് ഉപയോഗിക്കാൻ കഴിയില്ല.

എന്നാൽ മുമ്പത്തെ ഉദാഹരണത്തിന്റെ ഔട്ട്പുട്ട് തെറ്റാണ്. എന്തുകൊണ്ട്?

[^]* ഭാഗം ആദ്യം കഴിയുന്നത്ര പ്രതീകങ്ങൾ പകർത്താൻ ശ്രമിക്കും. ഇതുമൂലം റെഗുലർ സീക്വൻസിൻറെ അടുത്ത ഭാഗം ഒരു പൊരുത്തം കണ്ടെത്തിയില്ലെങ്കിൽ, അത് ഒരു പ്രതീകം പിൻവലിച്ച് വീണ്ടും ശ്രമിക്കും. ഉദാഹരണത്തിൽ, അൽഗോരിതം മുഴുവൻ വരിയും പിടിച്ചെടുക്കാൻ ശ്രമിക്കുന്നു, തുടർന്ന് തിരികെ ഉരുട്ടുന്നു. 4 പ്രതീകങ്ങൾ പിൻവലിച്ചുകഴിഞ്ഞാൽ, അവൻ വരിയിൽ */ കണ്ടെത്തും - ഇത് ഞങ്ങൾ ആഗ്രഹിച്ചതല്ല. ഒരു കമന്റ് മാത്രം എടുക്കാൻ ഞങ്ങൾ ആഗ്രഹിച്ചു, വരിയുടെ അവസാനത്തിൽ പോയി അവസാന കമന്റ് കണ്ടെത്തരുത്.

ഇക്കാരണത്താൽ, ആവർത്തന ഓപ്പറേറ്റർമാർ (+, *, ?, കൂടാതെ ()) അത്യാഗ്രഹികളാണെന്ന് ഞങ്ങൾ പറയുന്നു, അതായത് അവർ ആദ്യം കഴിയുന്നത്ര പിടിച്ച് തിരികെ പോകുന്നു. ഇതുപോലെയുള്ള (+?, *?, ??, ()?) ഒരു ഓപ്പറേറ്റർക്ക് ശേഷം നിങ്ങൾ ഒരു ചോദ്യം ചോദിക്കുകയാണെങ്കിൽ, അവർ അത്യാഗ്രഹമില്ലാത്തവരായി മാറുകയും സാധ്യമായ ഏറ്റവും ചെറിയ സംഭവങ്ങൾ കണ്ടെത്താൻ തുടങ്ങുകയും ചെയ്യും.

പിന്നെ അതാണ് നമുക്ക് വേണ്ടത്. ഒരു വരിയിൽ സാധ്യമായ ഏറ്റവും കുറഞ്ഞ പ്രതീകങ്ങളിൽ പൊരുത്തങ്ങൾ കണ്ടെത്താൻ നക്ഷത്രചിഹ്നത്തെ നിർബന്ധിക്കുന്നതിലൂടെ, ഞങ്ങൾ ഒരു ബ്ലോക്ക് കമന്റ് മാത്രമേ ഉപയോഗിക്കൂ, അതിൽ കൂടുതലൊന്നും ഇല്ല.

ഫംഗ്ഷൻ സ്ട്രിപ്പ് കമന്റുകൾ(കോഡ്) ( റിട്ടേൺ കോഡ്.replace(/\/\/.*|\/\*[^]*?\*\//g, ""); ) console.log(stripComments("1 /* a */+/* b */ 1")); // → 1 + 1

അത്യാഗ്രഹമില്ലാത്തവയ്ക്ക് പകരം അത്യാഗ്രഹമുള്ള ഓപ്പറേറ്റർമാരെ ഉപയോഗിക്കുമ്പോൾ നിരവധി പിശകുകൾ സംഭവിക്കുന്നു. റിപ്പീറ്റ് ഓപ്പറേറ്റർ ഉപയോഗിക്കുമ്പോൾ, എപ്പോഴും അത്യാഗ്രഹമില്ലാത്ത ഓപ്പറേറ്ററെ ആദ്യം പരിഗണിക്കുക.

ചലനാത്മകമായി RegExp ഒബ്ജക്റ്റുകൾ സൃഷ്ടിക്കുന്നു

എന്നാൽ നിങ്ങൾക്ക് സ്ട്രിംഗ് നിർമ്മിക്കാനും RegExp കൺസ്ട്രക്റ്റർ ഉപയോഗിക്കാനും കഴിയും. ഒരു ഉദാഹരണം ഇതാ:

വാർ പേര് = "ഹാരി"; var text = "ഹാരിയുടെ നെറ്റിയിൽ ഒരു പാടുണ്ട്."; var regexp = പുതിയ RegExp("\\b(" + name + ")\\b", "gi"); console.log(text.replace(regexp, "_$1_")); // → കൂടാതെ _ഹാരി_യുടെ നെറ്റിയിൽ ഒരു പാടുണ്ട്.

വാക്കുകളുടെ അതിരുകൾ സൃഷ്ടിക്കുമ്പോൾ, നമ്മൾ ഇരട്ട സ്ലാഷുകൾ ഉപയോഗിക്കേണ്ടതുണ്ട്, കാരണം ഞങ്ങൾ അവയെ ഒരു സാധാരണ വരിയിൽ എഴുതുന്നു, അല്ലാതെ ഫോർവേഡ് സ്ലാഷുകളുള്ള ഒരു ക്രമത്തിൽ അല്ല. RegExp-ലേക്കുള്ള രണ്ടാമത്തെ ആർഗ്യുമെന്റിൽ റെഗുലർ എക്സ്പ്രഷനുകൾക്കുള്ള ഓപ്ഷനുകൾ അടങ്ങിയിരിക്കുന്നു - ഞങ്ങളുടെ കാര്യത്തിൽ "gi", അതായത്. ആഗോളവും കേസ്-ഇൻസെൻസിറ്റീവും.

എന്നാൽ പേര് "dea+hlrd" ആണെങ്കിലോ (ഞങ്ങളുടെ ഉപയോക്താവ് ഒരു kulhatzker ആണെങ്കിൽ)? തൽഫലമായി, സ്ട്രിംഗിൽ പൊരുത്തങ്ങൾ കണ്ടെത്താത്ത അർത്ഥശൂന്യമായ ഒരു പതിവ് പദപ്രയോഗം നമുക്ക് ലഭിക്കും.

നമുക്ക് ഇഷ്ടപ്പെടാത്ത ഏത് കഥാപാത്രത്തിനും മുമ്പ് ബാക്ക്സ്ലാഷുകൾ ചേർക്കാം. \b അല്ലെങ്കിൽ \n പ്രത്യേക പ്രതീകങ്ങളായതിനാൽ നമുക്ക് അക്ഷരങ്ങൾക്ക് മുമ്പ് ബാക്ക്സ്ലാഷുകൾ ചേർക്കാൻ കഴിയില്ല. എന്നാൽ നിങ്ങൾക്ക് ആൽഫാന്യൂമെറിക് അല്ലാത്ത അക്ഷരങ്ങൾക്ക് മുമ്പായി സ്ലാഷുകൾ ചേർക്കാൻ കഴിയും.

Var പേര് = "dea+hlrd"; var text = "ഈ dea+hlrd എല്ലാവരേയും ശല്യപ്പെടുത്തുന്നതാണ്."; var രക്ഷപ്പെട്ടു = name.replace(/[^\w\s]/g, "\\$&"); var regexp = പുതിയ RegExp("\\b(" + രക്ഷപ്പെട്ടു + ")\\b", "gi"); console.log(text.replace(regexp, "_$1_")); // → ഈ _dea+hlrd_ എല്ലാവരെയും അലോസരപ്പെടുത്തി.

തിരയൽ രീതി

Console.log(" word".search(/\S/)); // → 2 console.log(" ".search(/\S/)); // → -1

നിർഭാഗ്യവശാൽ, ഒരു നിർദ്ദിഷ്ട ഓഫ്‌സെറ്റിൽ (നിങ്ങൾക്ക് ഇൻഡെക്‌സ്ഓഫ് ഉപയോഗിച്ച് ചെയ്യാൻ കഴിയുന്നതുപോലെ) ആരംഭിക്കുന്ന ഒരു പൊരുത്തത്തിനായി നോക്കുന്നതിനുള്ള രീതിയെ കുറിച്ച് പറയാൻ മാർഗമില്ല. അത് സഹായകരമാകും.

അവസാന സൂചിക പ്രോപ്പർട്ടി

ഒരു റീജക്സ് ഒബ്ജക്റ്റിന് ഗുണങ്ങളുണ്ട്. അവയിലൊന്ന് ഉറവിടമാണ്, അതിൽ ഒരു സ്ട്രിംഗ് അടങ്ങിയിരിക്കുന്നു. മറ്റൊന്ന് ലാസ്റ്റ് ഇൻഡക്‌സ് ആണ്, ചില വ്യവസ്ഥകൾക്ക് കീഴിൽ, സംഭവങ്ങൾക്കായുള്ള അടുത്ത തിരയൽ എവിടെ തുടങ്ങും.

ഗ്ലോബൽ ഓപ്‌ഷൻ g ഉണ്ടായിരിക്കണമെന്നും എക്‌സിക് രീതി ഉപയോഗിച്ചാണ് തിരയൽ നടത്തേണ്ടതെന്നും ഈ വ്യവസ്ഥകളിൽ ഉൾപ്പെടുന്നു. ഒരു അധിക ആർഗ്യുമെന്റ് എക്‌സ്‌എക്കിലേക്ക് കൈമാറാൻ അനുവദിക്കുക എന്നതാണ് കൂടുതൽ ന്യായമായ പരിഹാരം, എന്നാൽ ന്യായയുക്തത JavaScript regex ഇന്റർഫേസിന്റെ ഒരു അടിസ്ഥാന സവിശേഷതയല്ല.

Var പാറ്റേൺ = /y/g; pattern.lastIndex = 3; var പൊരുത്തം = pattern.exec("xyzzy"); console.log(match.index); // → 4 console.log(pattern.lastIndex); //→ 5

തിരയൽ വിജയകരമാണെങ്കിൽ, കണ്ടെത്തിയ സംഭവത്തിന് ശേഷമുള്ള സ്ഥാനത്തേക്ക് പോയിന്റ് ചെയ്യുന്നതിന് എക്‌സിക് കോൾ ലാസ്റ്റ് ഇൻഡക്‌സ് പ്രോപ്പർട്ടി അപ്‌ഡേറ്റ് ചെയ്യുന്നു. വിജയിച്ചില്ലെങ്കിൽ, അവസാന സൂചിക പൂജ്യമായി സജ്ജീകരിച്ചിരിക്കുന്നു - പുതുതായി സൃഷ്ടിച്ച ഒബ്‌ജക്റ്റിന്റെ അവസാന സൂചിക പോലെ.

ഒരു ഗ്ലോബൽ റെഗുലർ വേരിയബിളും ഒന്നിലധികം എക്‌സിക് കോളുകളും ഉപയോഗിക്കുമ്പോൾ, ഈ ഓട്ടോമാറ്റിക് ലാസ്റ്റ് ഇൻഡക്‌സ് അപ്‌ഡേറ്റുകൾ പ്രശ്‌നങ്ങൾ ഉണ്ടാക്കും. നിങ്ങളുടെ സാധാരണ സെർവറിന് മുമ്പത്തെ കോളിൽ നിന്ന് അവശേഷിക്കുന്ന സ്ഥാനത്ത് നിന്ന് തിരയൽ ആരംഭിക്കാനാകും.

വർ അക്കം = /\d/g; console.log(digit.exec("ഇതാ: 1")); // → ["1"] console.log(digit.exec("ഇപ്പോൾ: 1")); // → ശൂന്യം

മറ്റൊന്ന് രസകരമായ പ്രഭാവംമാച്ച് രീതി എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നത് മാറ്റുന്നതാണ് g ഓപ്ഷൻ. ഈ ഓപ്‌ഷൻ ഉപയോഗിച്ച് വിളിക്കുമ്പോൾ, എക്‌സിക്കിന്റെ ഫലത്തിന് സമാനമായ ഒരു അറേ റിട്ടേൺ ചെയ്യുന്നതിനുപകരം, അത് സ്‌ട്രിംഗിലെ പാറ്റേണിന്റെ എല്ലാ സംഭവങ്ങളും കണ്ടെത്തുകയും കണ്ടെത്തിയ സബ്‌സ്‌ട്രിംഗുകളുടെ ഒരു ശ്രേണി തിരികെ നൽകുകയും ചെയ്യുന്നു.

Console.log("Banana".match(/an/g)); // → ["an", "an"]

അതിനാൽ ആഗോള റെഗുലർ വേരിയബിളുകൾ ശ്രദ്ധിക്കുക. അവ ആവശ്യമുള്ള സന്ദർഭങ്ങൾ - കോളുകൾ മാറ്റിസ്ഥാപിക്കുക അല്ലെങ്കിൽ നിങ്ങൾ ലാസ്റ്റ്ഇൻഡക്സ് പ്രത്യേകമായി ഉപയോഗിക്കുന്ന സ്ഥലങ്ങൾ - അവ ഉപയോഗിക്കേണ്ട എല്ലാ കേസുകളും ആയിരിക്കും.

സംഭവ ചക്രങ്ങൾ

ലാസ്റ്റ് ഇൻഡക്സും എക്‌സെക്കും ഉപയോഗിച്ച് ലൂപ്പിന്റെ ബോഡിയിലുള്ള മാച്ച് ഒബ്‌ജക്‌റ്റിലേക്ക് ആക്‌സസ് ചെയ്യാൻ കഴിയുന്ന തരത്തിൽ ഒരു സ്‌ട്രിംഗിലെ പാറ്റേണിന്റെ എല്ലാ സംഭവങ്ങളിലൂടെയും ആവർത്തിക്കുക എന്നതാണ് ഒരു സാധാരണ ടാസ്‌ക്.

Var ഇൻപുട്ട് = "3 അക്കങ്ങളുള്ള ഒരു വരി... 42 ഉം 88 ഉം."; var നമ്പർ = /\b(\d+)\b/g; var പൊരുത്തം; while (match = number.exec(input)) console.log("കണ്ടെത്തിയത് ", പൊരുത്തം, " on ", match.index); // → 3 by 14 കണ്ടെത്തി // 42 by 33 കണ്ടെത്തി // 88 by 40 കണ്ടെത്തി

അസൈൻമെന്റിന്റെ മൂല്യം അസൈൻ ചെയ്യുന്ന മൂല്യമാണ് എന്ന വസ്തുത ഇത് പ്രയോജനപ്പെടുത്തുന്നു. മാച്ച് = re.exec(ഇൻപുട്ട്) ഒരു സമയത്ത് ലൂപ്പിൽ ഒരു വ്യവസ്ഥയായി ഉപയോഗിക്കുന്നതിലൂടെ, ഞങ്ങൾ ഓരോ ആവർത്തനത്തിന്റെയും തുടക്കത്തിൽ തിരയുകയും ഫലം ഒരു വേരിയബിളിൽ സംഭരിക്കുകയും എല്ലാ പൊരുത്തങ്ങളും കണ്ടെത്തുമ്പോൾ ലൂപ്പ് അവസാനിപ്പിക്കുകയും ചെയ്യുന്നു.

INI ഫയലുകൾ പാഴ്‌സ് ചെയ്യുന്നു

അധ്യായം അവസാനിപ്പിക്കാൻ, സാധാരണ പദപ്രയോഗങ്ങൾ ഉപയോഗിച്ച് ഒരു പ്രശ്നം നോക്കാം. ഇന്റർനെറ്റ് വഴി നമ്മുടെ ശത്രുക്കളെക്കുറിച്ചുള്ള വിവരങ്ങൾ സ്വയമേവ ശേഖരിക്കുന്ന ഒരു പ്രോഗ്രാം ഞങ്ങൾ എഴുതുകയാണെന്ന് സങ്കൽപ്പിക്കുക. (ഞങ്ങൾ മുഴുവൻ പ്രോഗ്രാമും എഴുതില്ല, ക്രമീകരണ ഫയൽ വായിക്കുന്ന ഭാഗം മാത്രം. ക്ഷമിക്കണം.) ഫയൽ ഇതുപോലെ കാണപ്പെടുന്നു:

സെർച്ച് എഞ്ചിൻ=http://www.google.com/search?q=$1 spitefulness=9.7 ; അഭിപ്രായങ്ങൾക്ക് മുമ്പ് ഒരു അർദ്ധവിരാമം സ്ഥാപിച്ചിരിക്കുന്നു; ഓരോ വിഭാഗവും വ്യത്യസ്‌ത ശത്രുവിന്റെ പൂർണ്ണനാമം=ലാറി ഡോ ടൈപ്പ്=കിന്റർഗാർട്ടൻ ബുൾ വെബ്‌സൈറ്റ്=http://www.geocities.com/CapeCanaveral/11451 fullname=Gargamel type=evil wizard outputdir=/home/marijn/enemies/gargamel

കൃത്യമായ ഫോർമാറ്റ്ഫയൽ (ഇത് വളരെ വ്യാപകമായി ഉപയോഗിക്കപ്പെടുന്നു, സാധാരണയായി INI എന്ന് വിളിക്കുന്നു), ഇനിപ്പറയുന്നവയാണ്:

അർദ്ധവിരാമത്തിൽ ആരംഭിക്കുന്ന ശൂന്യമായ വരകളും വരകളും അവഗണിക്കപ്പെടുന്നു
- ചതുര ബ്രാക്കറ്റുകളിൽ ഘടിപ്പിച്ചിരിക്കുന്ന വരികൾ ഒരു പുതിയ വിഭാഗം ആരംഭിക്കുന്നു
- ആൽഫാന്യൂമെറിക് ഐഡന്റിഫയർ അടങ്ങുന്ന വരികൾ = ഈ വിഭാഗത്തിൽ ഒരു ക്രമീകരണം ചേർക്കുക

ബാക്കിയെല്ലാം തെറ്റായ ഡാറ്റയാണ്.

അത്തരം ഒരു സ്‌ട്രിംഗിനെ ഒബ്‌ജക്‌റ്റുകളുടെ ഒരു നിരയിലേക്ക് പരിവർത്തനം ചെയ്യുക എന്നതാണ് ഞങ്ങളുടെ ചുമതല, ഓരോന്നിനും പേരിന്റെ പ്രോപ്പർട്ടിയും ക്രമീകരണങ്ങളുടെ ഒരു നിരയും ഉണ്ട്. ഓരോ വിഭാഗത്തിനും ഒരു ഒബ്‌ജക്‌റ്റ് ആവശ്യമാണ്, കൂടാതെ ഒന്ന് കൂടി ആഗോള ക്രമീകരണങ്ങൾഫയലിന്റെ മുകളിൽ.

ഫയൽ വരി വരിയായി പാഴ്‌സ് ചെയ്യേണ്ടതിനാൽ, ഫയലിനെ വരികളായി വിഭജിച്ച് ആരംഭിക്കുന്നത് നല്ലതാണ്. ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ അധ്യായം 6-ൽ string.split("\n") ഉപയോഗിച്ചു. ചില ഓപ്പറേറ്റിംഗ് സിസ്റ്റങ്ങൾ ലൈൻ ബ്രേക്കുകൾക്കായി ഒരു \n പ്രതീകമല്ല, രണ്ട് - \r\n ഉപയോഗിക്കുന്നു. സ്പ്ലിറ്റ് രീതി സാധാരണ പദപ്രയോഗങ്ങളെ ഒരു ആർഗ്യുമെന്റായി എടുക്കുന്നതിനാൽ, /\r?\n/ എന്ന പദപ്രയോഗം ഉപയോഗിച്ച് നമുക്ക് വരികൾ വിഭജിക്കാം, ഒറ്റ \n, \r\n എന്നിവ വരികൾക്കിടയിൽ അനുവദിക്കും.

ഫംഗ്‌ഷൻ parseINI(string) ( // ടോപ്പ്-ലെവൽ ക്രമീകരണങ്ങൾ അടങ്ങിയ ഒരു ഒബ്‌ജക്‌റ്റിൽ നമുക്ക് ആരംഭിക്കാം var currentSection = (പേര്: null, ഫീൽഡുകൾ: ); var category = ; string.split(/\r?\n/).forEach(function (ലൈൻ ) ( var പൊരുത്തം; എങ്കിൽ (/^\s*(;.*)?$/.ടെസ്റ്റ്(ലൈൻ)) (മടങ്ങുക; ) അല്ലെങ്കിൽ (മാച്ച് = line.match(/^\[(.*))\ ]$ /)) (നിലവിലെ വിഭാഗം = (പേര്: പൊരുത്തം, ഫീൽഡുകൾ: ); category.push(currentSection); ) അല്ലെങ്കിൽ (match = line.match(/^(\w+)=(.*)$/)) ( currentSection. fields.push((പേര്: പൊരുത്തം, മൂല്യം: പൊരുത്തം)); ) വേറെ (പുതിയ പിശക് ("" + ലൈൻ + "" വരിയിൽ അസാധുവായ ഡാറ്റ അടങ്ങിയിരിക്കുന്നു."); ) ); വിഭാഗങ്ങൾ തിരികെ നൽകുക; )

കോഡ് എല്ലാ വരികളിലൂടെയും കടന്നുപോകുന്നു, നിലവിലെ വിഭാഗം ഒബ്ജക്റ്റ് "നിലവിലെ വിഭാഗം" അപ്ഡേറ്റ് ചെയ്യുന്നു. ആദ്യം, /^\s*(;.*)?$/ എന്ന പതിവ് പദപ്രയോഗം ഉപയോഗിച്ച് ലൈൻ അവഗണിക്കാനാകുമോ എന്ന് ഇത് പരിശോധിക്കുന്നു. ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് നിങ്ങൾക്ക് സങ്കൽപ്പിക്കാൻ കഴിയുമോ? ബ്രാക്കറ്റുകൾക്കിടയിലുള്ള ഭാഗം കമന്റുകളുമായി പൊരുത്തപ്പെടുന്നു, അല്ലേ? സാധാരണ പ്രതീകം സ്‌പെയ്‌സുകൾ മാത്രമുള്ള വരികളുമായി പൊരുത്തപ്പെടുന്ന തരത്തിലാക്കുന്നു.

ലൈൻ ഒരു അഭിപ്രായമല്ലെങ്കിൽ, അത് ഒരു പുതിയ വിഭാഗം ആരംഭിക്കുന്നുണ്ടോ എന്ന് കോഡ് പരിശോധിക്കുന്നു. അതെ എങ്കിൽ, അത് നിലവിലെ വിഭാഗത്തിനായി ഒരു പുതിയ ഒബ്‌ജക്‌റ്റ് സൃഷ്‌ടിക്കുന്നു, അതിൽ തുടർന്നുള്ള ക്രമീകരണങ്ങൾ ചേർക്കുന്നു.

അവസാനത്തെ അർത്ഥവത്തായ സാധ്യത, സ്ട്രിംഗ് ഒരു സാധാരണ ക്രമീകരണമാണ്, ഈ സാഹചര്യത്തിൽ അത് നിലവിലെ ഒബ്‌ജക്റ്റിലേക്ക് ചേർക്കുന്നു.

ഓപ്ഷനുകളൊന്നും പ്രവർത്തിക്കുന്നില്ലെങ്കിൽ, ഫംഗ്ഷൻ ഒരു പിശക് എറിയുന്നു.

^, $ എന്നിവയുടെ പതിവ് ഉപയോഗം, എക്സ്പ്രഷൻ അതിന്റെ ഭാഗത്തിന് പകരം മുഴുവൻ സ്‌ട്രിംഗുമായി പൊരുത്തപ്പെടുന്നുണ്ടെന്ന് ഉറപ്പാക്കുന്നത് എങ്ങനെയെന്ന് ശ്രദ്ധിക്കുക. നിങ്ങൾ അവ ഉപയോഗിക്കുന്നില്ലെങ്കിൽ, കോഡ് സാധാരണയായി പ്രവർത്തിക്കും, പക്ഷേ ചിലപ്പോൾ വിചിത്രമായ ഫലങ്ങൾ പുറപ്പെടുവിക്കും, പിശക് ട്രാക്കുചെയ്യാൻ പ്രയാസമായിരിക്കും.

if (match = string.match(...)) കൺസ്ട്രക്‌റ്റ് ഒരു സമയത്ത് ലൂപ്പിൽ അസൈൻമെന്റ് ഒരു വ്യവസ്ഥയായി ഉപയോഗിക്കുന്ന തന്ത്രത്തിന് സമാനമാണ്. മാച്ച് കോൾ വിജയിക്കുമെന്ന് പലപ്പോഴും നിങ്ങൾക്കറിയില്ല, അതിനാൽ അത് പരിശോധിക്കുന്ന if ബ്ലോക്കിനുള്ളിൽ മാത്രമേ നിങ്ങൾക്ക് റിസൾട്ട് ഒബ്ജക്റ്റ് ആക്സസ് ചെയ്യാൻ കഴിയൂ. if ചെക്കുകളുടെ മനോഹരമായ ശൃംഖല തകർക്കാതിരിക്കാൻ, ഞങ്ങൾ തിരയൽ ഫലം ഒരു വേരിയബിളിന് നൽകുകയും ഉടൻ തന്നെ ഈ അസൈൻമെന്റ് ഒരു ചെക്കായി ഉപയോഗിക്കുകയും ചെയ്യുന്നു.

അന്താരാഷ്ട്ര ചിഹ്നങ്ങൾ

വിചിത്രമായ യാദൃശ്ചികമായി, ചരിത്രപരമായി \s (സ്പേസ്) യുണിക്കോഡിൽ വൈറ്റ്‌സ്‌പെയ്‌സ് ആയി കണക്കാക്കുന്ന എല്ലാ പ്രതീകങ്ങളുമായും പൊരുത്തപ്പെടുന്നു, ഇതുപോലുള്ള കാര്യങ്ങൾ ഉൾപ്പെടെ നോൺ-ബ്രേക്കിംഗ് സ്പേസ്അല്ലെങ്കിൽ മംഗോളിയൻ സ്വരാക്ഷര വിഭജനം.

മറ്റ് ഭാഷകളിലെ ചില റീജക്‌സ് നടപ്പിലാക്കലുകൾക്ക് "എല്ലാം പോലെയുള്ള യൂണികോഡ് പ്രതീകങ്ങളുടെ പ്രത്യേക വിഭാഗങ്ങൾക്കായി തിരയുന്നതിന് പ്രത്യേക വാക്യഘടനയുണ്ട്. വലിയ അക്ഷരങ്ങൾ", "എല്ലാ വിരാമചിഹ്നങ്ങളും" അല്ലെങ്കിൽ "നിയന്ത്രണ പ്രതീകങ്ങൾ". ജാവാസ്ക്രിപ്റ്റിലേക്ക് അത്തരം വിഭാഗങ്ങൾ ചേർക്കാൻ പദ്ധതിയുണ്ട്, പക്ഷേ അവ ഉടൻ നടപ്പിലാക്കിയേക്കില്ല.

താഴത്തെ വരി

സ്ട്രിംഗുകളിലെ തിരയൽ പാറ്റേണുകളെ പ്രതിനിധീകരിക്കുന്ന വസ്തുക്കളാണ് റെഗുലറുകൾ. ഈ പാറ്റേണുകൾ പ്രകടിപ്പിക്കാൻ അവർ സ്വന്തം വാക്യഘടന ഉപയോഗിക്കുന്നു.

/abc/ പ്രതീക ശ്രേണി
// ലിസ്റ്റിൽ നിന്നുള്ള ഏതെങ്കിലും പ്രതീകം
/[^abc]/ ലിസ്റ്റിൽ നിന്നുള്ള പ്രതീകങ്ങൾ ഒഴികെയുള്ള ഏത് പ്രതീകവും
// ഇടവേളയിൽ നിന്നുള്ള ഏതെങ്കിലും കഥാപാത്രം
/x+/ x പാറ്റേണിന്റെ ഒന്നോ അതിലധികമോ സംഭവങ്ങൾ
/x+?/ ഒന്നോ അതിലധികമോ സംഭവങ്ങൾ, അത്യാഗ്രഹമില്ലാത്തത്
/x*/ പൂജ്യം അല്ലെങ്കിൽ കൂടുതൽ സംഭവങ്ങൾ
/x?/ പൂജ്യം അല്ലെങ്കിൽ ഒരു സംഭവം
/x(2,4)/ രണ്ട് മുതൽ നാല് വരെ സംഭവങ്ങൾ
/(abc)/ ഗ്രൂപ്പ്
/a|b|c/ നിരവധി പാറ്റേണുകളിൽ ഏതെങ്കിലും
/\d/ ഏതെങ്കിലും നമ്പർ
/\w/ ഏതെങ്കിലും ആൽഫാന്യൂമെറിക് പ്രതീകം ("അക്ഷരം")
/\s/ ഏതെങ്കിലും വൈറ്റ്‌സ്‌പേസ് പ്രതീകം
// ന്യൂലൈനുകൾ ഒഴികെയുള്ള ഏത് പ്രതീകവും
/\b/ പദ പരിധി
/^/ വരിയുടെ തുടക്കം
/$/ വരിയുടെ അവസാനം

പാറ്റേൺ സ്ട്രിംഗിൽ ഉണ്ടോ എന്ന് പരിശോധിക്കാൻ regex-ന് ഒരു ടെസ്റ്റ് രീതിയുണ്ട്. കണ്ടെത്തിയ എല്ലാ ഗ്രൂപ്പുകളും അടങ്ങുന്ന ഒരു അറേ തിരികെ നൽകുന്ന ഒരു എക്‌സിക് മെത്തേഡ് ഉണ്ട്. അറേയ്‌ക്ക് ഒരു ഇൻഡക്‌സ് പ്രോപ്പർട്ടി ഉണ്ട്, അതിൽ പൊരുത്തമുണ്ടായ പ്രതീകത്തിന്റെ എണ്ണം അടങ്ങിയിരിക്കുന്നു.

പാറ്റേണുകൾ പൊരുത്തപ്പെടുത്തുന്നതിന് സ്ട്രിംഗുകൾക്ക് ഒരു പൊരുത്ത രീതിയും സംഭവത്തിന്റെ ആരംഭ സ്ഥാനം മാത്രം നൽകുന്ന ഒരു തിരയൽ രീതിയും ഉണ്ട്. മാറ്റിസ്ഥാപിക്കുന്ന രീതിക്ക് ഒരു പാറ്റേണിന്റെ സംഭവങ്ങളെ മറ്റൊരു സ്ട്രിംഗ് ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കാൻ കഴിയും. കൂടാതെ, നിങ്ങൾക്ക് മാറ്റിസ്ഥാപിക്കുന്നതിനുള്ള ഒരു ഫംഗ്‌ഷൻ കൈമാറാൻ കഴിയും, അത് ടെംപ്ലേറ്റിന്റെയും കണ്ടെത്തിയ ഗ്രൂപ്പുകളുടെയും അടിസ്ഥാനത്തിൽ ഒരു റീപ്ലേസ്‌മെന്റ് ലൈൻ നിർമ്മിക്കും.

സാധാരണ പ്രതീകങ്ങൾക്ക് ക്ലോസിംഗ് സ്ലാഷിന് ശേഷം എഴുതുന്ന ക്രമീകരണങ്ങളുണ്ട്. i ഓപ്‌ഷൻ റെഗുലർ എക്‌സ്‌പ്രഷൻ കേസ്-ഇൻസെൻസിറ്റീവ് ആക്കുന്നു, കൂടാതെ g ഓപ്‌ഷൻ അതിനെ ഗ്ലോബൽ ആക്കുന്നു, ഇത് മറ്റ് കാര്യങ്ങളിൽ, ആദ്യത്തേത് മാത്രമല്ല, കണ്ടെത്തിയ എല്ലാ സംഭവങ്ങളെയും മാറ്റിസ്ഥാപിക്കാൻ റീപ്ലേസ് മെത്തേഡ് കാരണമാകുന്നു.

സ്ട്രിംഗുകളിൽ നിന്ന് പതിവ് എക്സ്പ്രഷനുകൾ സൃഷ്ടിക്കാൻ RegExp കൺസ്ട്രക്റ്റർ ഉപയോഗിക്കാം.

അസുഖകരമായ ഹാൻഡിൽ ഉള്ള മൂർച്ചയുള്ള ഉപകരണമാണ് റെഗുലേറ്ററുകൾ. അവ ചില ജോലികൾ വളരെ ലളിതമാക്കുന്നു, മറ്റ് സങ്കീർണ്ണമായ പ്രശ്നങ്ങൾ പരിഹരിക്കുമ്പോൾ അവ കൈകാര്യം ചെയ്യാൻ കഴിയില്ല. റീജക്‌സുകൾ ഉപയോഗിക്കാൻ പഠിക്കുന്നതിന്റെ ഭാഗമാണ്, അവർ ഉദ്ദേശിക്കാത്ത ഒരു ടാസ്‌ക്കിൽ അവരെ നിറയ്ക്കാനുള്ള പ്രലോഭനത്തെ ചെറുക്കാൻ കഴിയുക എന്നതാണ്.

വ്യായാമങ്ങൾ

പതിവ് ഗോൾഫ്

ഓരോ സബ്‌ലൈനുകൾക്കും, വരിയിൽ അവയുടെ സ്ഥാനം പരിശോധിക്കാൻ ഒരു സാധാരണ എക്‌സ്‌പ്രഷൻ എഴുതുക. സാധാരണ എഞ്ചിൻ ഈ നിർദ്ദിഷ്‌ട സബ്‌സ്ട്രിംഗുകൾ മാത്രമേ കണ്ടെത്താവൂ. പ്രത്യേകമായി പരാമർശിക്കാത്ത പക്ഷം വാക്കുകളുടെ അതിരുകളെ കുറിച്ച് വിഷമിക്കേണ്ട. നിങ്ങൾക്ക് ഒരു വർക്കിംഗ് റെഗുലർ പാറ്റേൺ ഉള്ളപ്പോൾ, അത് കുറയ്ക്കാൻ ശ്രമിക്കുക.

കാറും പൂച്ചയും
- പോപ്പും പ്രോപ്പും
- ഫെററ്റ്, ഫെറി, ഫെരാരി
- ious എന്നതിൽ അവസാനിക്കുന്ന ഏതൊരു വാക്കും
- ഒരു സ്പേസ്, തുടർന്ന് ഒരു പീരിയഡ്, കോമ, കോളൻ അല്ലെങ്കിൽ അർദ്ധവിരാമം.
- ആറ് അക്ഷരങ്ങളിൽ കൂടുതൽ നീളമുള്ള ഒരു വാക്ക്
- അക്ഷരങ്ങളില്ലാത്ത വാക്ക് ഇ

// നിങ്ങളുടെ സ്ഥിരം പദപ്രയോഗങ്ങൾ പരിശോധിക്കുക(/.../, ["എന്റെ കാർ", "ചീത്ത പൂച്ചകൾ"], ["ക്യാമ്പർ", "ഹൈ ആർട്ട്"]); സ്ഥിരീകരിക്കുക(/.../, ["പോപ്പ് കൾച്ചർ", "മാഡ് പ്രോപ്സ്"], ["പ്ലോപ്പ്"]); സ്ഥിരീകരിക്കുക(/.../, ["ഫെററ്റ്", "ഫെറി", "ഫെരാരി"], ["ഫെറം", "ട്രാൻസ്ഫർ എ"]); സ്ഥിരീകരിക്കുക(/.../, ["എത്ര രുചികരമായത്", "വിശാലമായ മുറി"], ["നാശം", "ബോധം"]); സ്ഥിരീകരിക്കുക(/.../, ["മോശമായ വിരാമചിഹ്നം ."], ["എസ്കേപ്പ് ദി ഡോട്ട്"]); സ്ഥിരീകരിക്കുക(/.../, ["hottenottenten"], ["no", "hotten totten tenten"]); സ്ഥിരീകരിക്കുക(/.../, ["റെഡ് പ്ലാറ്റിപസ്", "ചലിക്കുന്ന നെസ്റ്റ്"], ["എർത്ത് ബെഡ്", "ലേണിംഗ് ആപ്പ്"]); ഫംഗ്‌ഷൻ വെരിഫൈ(regexp, yes, no) ( // (regexp.source == "...") മടങ്ങുകയാണെങ്കിൽ പൂർത്തിയാകാത്ത വ്യായാമങ്ങൾ അവഗണിക്കുക; yes.forEach(function(s) ((!regexp.test(s)) കൺസോൾ ആണെങ്കിൽ .log("കണ്ടില്ല" """);));)

വാചകത്തിലെ ഉദ്ധരണികൾ

ഉദ്ധരണികളുടെ ഈ രണ്ട് ഉപയോഗങ്ങൾ തമ്മിൽ വേർതിരിച്ചറിയുന്ന ഒരു പാറ്റേൺ കൊണ്ടുവരിക, പകരം മാറ്റിസ്ഥാപിക്കുന്ന രീതിയിലേക്ക് ഒരു കോൾ എഴുതുക.

വീണ്ടും നമ്പറുകൾ

എഴുതിയിരിക്കുന്ന അക്കങ്ങൾ മാത്രം കണ്ടെത്തുന്ന ഒരു പദപ്രയോഗം എഴുതുക ജാവാസ്ക്രിപ്റ്റ് ശൈലി. ഇത് സംഖ്യയ്‌ക്ക് മുമ്പായി സാധ്യമായ മൈനസ് അല്ലെങ്കിൽ പ്ലസ് പിന്തുണയ്ക്കണം, ഒരു ദശാംശ പോയിന്റ്, കൂടാതെ ശാസ്ത്രീയ നൊട്ടേഷൻ 5e-3 അല്ലെങ്കിൽ 1E10 - വീണ്ടും സാധ്യമായ പ്ലസ് അല്ലെങ്കിൽ മൈനസ്. ഡോട്ടിന് മുമ്പോ ശേഷമോ അക്കങ്ങൾ ഉണ്ടാകണമെന്നില്ല, എന്നാൽ സംഖ്യയിൽ ഒരൊറ്റ ഡോട്ട് ഉൾക്കൊള്ളാൻ കഴിയില്ല എന്നതും ശ്രദ്ധിക്കുക. അതായത്, .5 അല്ലെങ്കിൽ 5. സാധുവായ സംഖ്യകളാണ്, എന്നാൽ ഒരു ഡോട്ട് അങ്ങനെയല്ല.

// ഇവിടെ റെഗുലർ സീക്വൻസ് നൽകുക. var നമ്പർ = /^...$/; // ടെസ്റ്റുകൾ: ["1", "-1", "+15", "1.55", ".5", "5.", "1.3e2", "1E-4", "1e+12"] .forEach(function(s) (!number.test(s)) console.log("കണ്ടെത്താനായില്ല "" + s + """); )); ["1a", "+-1", "1.2.3", "1+1", "1e4.5", ".5.", "1f5", "."].forEach(function(s) ((number.test(കൾ)) console.log("തെറ്റായി അംഗീകരിച്ചിട്ടുണ്ടെങ്കിൽ "" + s + """); ));

ഒരു സാധാരണ പദപ്രയോഗം എന്നത് ഒരു പ്രതീക പാറ്റേൺ വിവരിക്കുന്ന ഒരു വസ്തുവാണ്. JavaScript-ലെ RegExp ക്ലാസ് റെഗുലർ എക്സ്പ്രഷനുകളെ പ്രതിനിധീകരിക്കുന്നു, കൂടാതെ String, RegExp ക്ലാസ് ഒബ്‌ജക്‌റ്റുകൾ പാറ്റേൺ പൊരുത്തപ്പെടുത്തലും ടെക്‌സ്‌റ്റ് തിരയലും മാറ്റിസ്ഥാപിക്കൽ പ്രവർത്തനങ്ങളും നടത്താൻ സാധാരണ എക്‌സ്‌പ്രഷനുകൾ ഉപയോഗിക്കുന്ന രീതികളെ നിർവചിക്കുന്നു.

പതിവ് പദപ്രയോഗങ്ങളാണ് ശക്തമായ ഉപകരണംഇൻകമിംഗ് ഡാറ്റ പ്രോസസ്സ് ചെയ്യാൻ. ടെക്‌സ്‌റ്റ് മാറ്റിസ്ഥാപിക്കുകയോ തിരയുകയോ ചെയ്യേണ്ട ഒരു ടാസ്‌ക്ക് ഈ “ഒരു ഭാഷയ്ക്കുള്ളിലെ ഭാഷ” ഉപയോഗിച്ച് മനോഹരമായി പരിഹരിക്കാനാകും.

സൃഷ്ടി

IN JavaScript റെഗുലർഎക്സ്പ്രഷനുകൾ RegExp ഒബ്ജക്റ്റുകൾ പ്രതിനിധീകരിക്കുന്നു. RegExp ഒബ്‌ജക്റ്റുകൾ RegExp() കൺസ്ട്രക്‌റ്റർ ഉപയോഗിച്ച് സൃഷ്‌ടിക്കാൻ കഴിയും, എന്നാൽ മിക്കപ്പോഴും അവ ഒരു പ്രത്യേക ലിറ്ററൽ വാക്യഘടന ഉപയോഗിച്ചാണ് സൃഷ്‌ടിക്കുന്നത്. സൃഷ്ടി രീതികൾ:

// ഒരു സാധാരണ പദപ്രയോഗം അക്ഷരാർത്ഥത്തിൽ ഉപയോഗിക്കുന്നു: var re = /ab+c/;

സ്‌ക്രിപ്റ്റ് പാഴ്‌സ് ചെയ്യുമ്പോൾ റെഗുലർ എക്‌സ്‌പ്രഷൻ ലിറ്ററലുകൾ മുൻകൂട്ടി കംപൈൽ ചെയ്യാൻ കാരണമാകുന്നു.

// RegExp ഒബ്‌ജക്റ്റ് var re = new RegExp("ab+c") ന്റെ ഫംഗ്‌ഷൻ കൺസ്‌ട്രക്‌ടറിനെ വിളിക്കുന്നു;

ഒരു കൺസ്ട്രക്റ്റർ ഉപയോഗിക്കുന്നത് സ്ക്രിപ്റ്റ് എക്സിക്യൂഷൻ സമയത്ത് റെഗുലർ എക്സ്പ്രഷൻ കംപൈൽ ചെയ്യുകയാണ്. ഉപയോഗിക്കുക ഈ രീതിപദപ്രയോഗം മാറുമെന്ന് അറിയാമെങ്കിൽ അത്യാവശ്യമാണ്.

പതിവ് ഭാവത്തിൽ പ്രത്യേക പ്രതീകങ്ങൾ

\ - സാധാരണ കഥാപാത്രങ്ങൾക്ക് - അവരെ സവിശേഷമാക്കുന്നു. ഉദാഹരണത്തിന്, /s/ എന്ന പദപ്രയോഗം 's' എന്ന പ്രതീകത്തിനായി തിരയുന്നു. നിങ്ങൾ s-ന് മുമ്പ് \ ഇടുകയാണെങ്കിൽ, /\s/ ഇതിനകം ഒരു സ്പേസ് പ്രതീകത്തെ സൂചിപ്പിക്കുന്നു.

^ - ഇൻപുട്ട് ഡാറ്റയുടെ ആരംഭം സൂചിപ്പിക്കുന്നു. മൾട്ടി-ലൈൻ തിരയൽ ഫ്ലാഗ് ("m") സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, അത് ഒരു പുതിയ വരിയുടെ തുടക്കത്തിലും പ്രവർത്തിക്കും.

$ - ഇൻപുട്ട് ഡാറ്റയുടെ അവസാനം സൂചിപ്പിക്കുന്നു. മൾട്ടിലൈൻ തിരയൽ ഫ്ലാഗ് സജ്ജീകരിച്ചിട്ടുണ്ടെങ്കിൽ, അത് വരിയുടെ അവസാനത്തിലും പ്രവർത്തിക്കും.

* - ആവർത്തനം 0 അല്ലെങ്കിൽ അതിൽ കൂടുതൽ തവണ സൂചിപ്പിക്കുന്നു. ഉദാഹരണത്തിന്, /bo*/ "A ghost booooed" എന്നതിൽ 'boooo' എന്നും "A bird warbled" എന്നതിൽ 'b' എന്നും കണ്ടെത്തും, എന്നാൽ "A goat grunted" എന്നതിൽ ഒന്നും കണ്ടെത്തുകയില്ല.

+ - ഒന്നോ അതിലധികമോ തവണ ആവർത്തിക്കുന്നതിനെ സൂചിപ്പിക്കുന്നു. (1,) ന് തുല്യമാണ്. ഉദാഹരണത്തിന്, "കാൻഡി" എന്നതിലെ 'a'കളും "caaaaaandy" എന്നതിലെ എല്ലാ 'a'കളും /a+/ പൊരുത്തപ്പെടും.

? - മൂലകം ഉണ്ടായിരിക്കാം അല്ലെങ്കിൽ ഇല്ലായിരിക്കാം എന്ന് സൂചിപ്പിക്കുന്നു.

. - (ഡെസിമൽ പോയിന്റ്) ഒരു പുതിയ വരി ഒഴികെയുള്ള ഏതൊരു പ്രതീകത്തെയും പ്രതിനിധീകരിക്കുന്നു: \n \r \u2028 അല്ലെങ്കിൽ \u2029. (പുതിയ ലൈനുകൾ ഉൾപ്പെടെ ഏത് പ്രതീകവും തിരയാൻ നിങ്ങൾക്ക് [\s\S] ഉപയോഗിക്കാം).

(x)– x കണ്ടെത്തി ഓർക്കുന്നു. ഇതിനെ "മെമ്മറി ബ്രാക്കറ്റുകൾ" എന്ന് വിളിക്കുന്നു. ഉദാഹരണത്തിന്, /(foo)/ "foo ബാറിൽ" 'foo' കണ്ടെത്തുകയും ഓർമ്മിക്കുകയും ചെയ്യും. കണ്ടെത്തിയ സബ്‌സ്‌ട്രിംഗ് തിരയൽ ഫല ശ്രേണിയിലോ RegExp ഒബ്‌ജക്റ്റിന്റെ മുൻ നിർവചിച്ച പ്രോപ്പർട്ടികളിലോ സംഭരിച്ചിരിക്കുന്നു: $1, ..., $9.

(?:x)- x കണ്ടെത്തുന്നു, പക്ഷേ അത് കണ്ടെത്തുന്നത് ഓർക്കുന്നില്ല. ഇതിനെ "ഓർമ്മിക്കാത്ത പരാൻതീസിസ്" എന്ന് വിളിക്കുന്നു. കണ്ടെത്തിയ സബ്‌സ്‌ട്രിംഗ് ഫലങ്ങളുടെ അറേയിലും RegExp പ്രോപ്പർട്ടികളിലും സംഭരിച്ചിട്ടില്ല. എല്ലാ ബ്രാക്കറ്റുകളും പോലെ, അവയിൽ ഉള്ളത് ഒരൊറ്റ ഉപപാറ്റേണിലേക്ക് കൂട്ടിച്ചേർക്കുന്നു.

x(?=y)– x ന് ശേഷം y ഉണ്ടെങ്കിൽ മാത്രം x കണ്ടെത്തുന്നു. ഉദാഹരണത്തിന്, /Jack(?=Sprat)/ 'Jack' എന്നതിന് ശേഷം 'Sprat' ആണെങ്കിൽ മാത്രമേ പൊരുത്തപ്പെടൂ. /Jack(?=Sprat|Frost)/ 'Sprat' അല്ലെങ്കിൽ 'Frost' എന്നതിന് ശേഷം മാത്രമേ 'Jack' കണ്ടെത്തൂ. എന്നിരുന്നാലും, തിരയൽ ഫലത്തിൽ 'Sprat' അല്ലെങ്കിൽ 'Frost' എന്നിവ ദൃശ്യമാകില്ല.

x(?!y)– x ന് ശേഷം y ഇല്ലെങ്കിൽ മാത്രം x കണ്ടെത്തുന്നു. ഉദാഹരണത്തിന്, /\d+(?!\.)/ ഒരു സംഖ്യയെ പിന്തുടരുന്നില്ലെങ്കിൽ മാത്രമേ പൊരുത്തപ്പെടൂ ദശാംശ. /\d+(?!\.)/.exec(“3.141”) 141 കണ്ടെത്തും, പക്ഷേ 3.141 അല്ല.

x|y– x അല്ലെങ്കിൽ y കണ്ടെത്തുന്നു. ഉദാഹരണത്തിന്, /green|red/ "പച്ച ആപ്പിളിൽ" 'പച്ച' എന്നതും "ചുവപ്പ് ആപ്പിളിൽ" 'ചുവപ്പ്' എന്നതുമായി പൊരുത്തപ്പെടും.

(n)- പോസിറ്റീവ് പൂർണ്ണസംഖ്യ. മുമ്പത്തെ മൂലകത്തിന്റെ കൃത്യമായി n ആവർത്തനങ്ങൾ കണ്ടെത്തുന്നു.

(n,)- പോസിറ്റീവ് പൂർണ്ണസംഖ്യ. ഒരു മൂലകത്തിന്റെ n അല്ലെങ്കിൽ കൂടുതൽ ആവർത്തനങ്ങൾ കണ്ടെത്തുന്നു.

(n,m)- പോസിറ്റീവ് പൂർണ്ണസംഖ്യകൾ. മൂലകത്തിന്റെ n മുതൽ m വരെയുള്ള ആവർത്തനങ്ങൾ കണ്ടെത്തുക.

- പ്രതീക സെറ്റ്. ലിസ്‌റ്റ് ചെയ്‌ത ഏതെങ്കിലും പ്രതീകങ്ങൾ കണ്ടെത്തുന്നു. ഒരു ഡാഷ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു വിടവ് സൂചിപ്പിക്കാൻ കഴിയും. ഉദാഹരണത്തിന്, - അതേ പോലെ.

[^xyz]- സെറ്റിൽ വ്യക്തമാക്കിയിട്ടുള്ളവ ഒഴികെയുള്ള ഏത് കഥാപാത്രവും. നിങ്ങൾക്ക് ഒരു സ്പാൻ വ്യക്തമാക്കാനും കഴിയും. ഉദാഹരണത്തിന്, [^abc] എന്നത് [^a-c] പോലെയാണ്.

[\b]- ബാക്ക്‌സ്‌പേസ് പ്രതീകം കണ്ടെത്തുന്നു.

\b- പദത്തിന്റെ അതിരുകൾ (ലാറ്റിൻ) കണ്ടെത്തുന്നു.

\B- ഇത് ഒരു പദത്തിന്റെ അതിരുകളെ സൂചിപ്പിക്കുന്നില്ല. ഉദാഹരണത്തിന്, /\w\Bn/ "ഉച്ച" എന്നതിൽ 'ഓൺ' എന്നതുമായി പൊരുത്തപ്പെടും, കൂടാതെ /y\B\w/ "ഇന്നലെ" എന്നതിൽ 'ye' എന്നതുമായി പൊരുത്തപ്പെടും.

\cX– X എന്നത് A മുതൽ Z വരെയുള്ള ഒരു അക്ഷരമാണ്. ഒരു സ്ട്രിംഗിലെ ഒരു നിയന്ത്രണ പ്രതീകത്തെ സൂചിപ്പിക്കുന്നു. ഉദാഹരണത്തിന്, /\cM/ എന്നത് Ctrl-M പ്രതീകത്തെ പ്രതിനിധീകരിക്കുന്നു.

\d- ഏത് അക്ഷരമാലയിൽ നിന്നും ഒരു നമ്പർ കണ്ടെത്തുന്നു.

\D- ഒരു നോൺ-സംഖ്യാ പ്രതീകം (എല്ലാ അക്ഷരമാലകളും) കണ്ടെത്തുന്നു. [^0-9] എന്നത് സാധാരണ സംഖ്യകൾക്ക് തുല്യമാണ്.

\f,\r,\n- അനുബന്ധ പ്രത്യേക പ്രതീകങ്ങൾ ഫോം-ഫീഡ്, ലൈൻ-ഫീഡ്, ലൈൻ ഫീഡ്.

\s- സ്പേസ്, ടാബ്, ലൈൻ ഫീഡുകൾ, മറ്റ് യൂണികോഡ് പ്രതീകങ്ങൾ എന്നിവയുൾപ്പെടെ ഏത് വൈറ്റ്‌സ്‌പെയ്‌സ് പ്രതീകവും കണ്ടെത്തുന്നു വൈറ്റ്‌സ്‌പേസ് പ്രതീകങ്ങൾ.

\S- വൈറ്റ്‌സ്‌പെയ്‌സ് ഒഴികെയുള്ള ഏത് പ്രതീകവും കണ്ടെത്തുന്നു.

\t- ടാബ് പ്രതീകം.

\v- ലംബ ടാബ് പ്രതീകം.

\w- അക്ഷരങ്ങൾ, അക്കങ്ങൾ, അടിവരകൾ എന്നിവ ഉൾപ്പെടെ ഏതെങ്കിലും (ലാറ്റിൻ) പദ പ്രതീകം കണ്ടെത്തുന്നു. തത്തുല്യം.

\W- ഏതെങ്കിലും (ലാറ്റിൻ ഇതര) പദ ചിഹ്നം കണ്ടെത്തും. [^A-Za-z0-9_] എന്നതിന് തുല്യമാണ്.

\0 – NUL പ്രതീകം കണ്ടെത്തുന്നു.

\xhh- hh (2 ഹെക്സാഡെസിമൽ അക്കങ്ങൾ) കോഡ് ഉള്ള ഒരു പ്രതീകം കണ്ടെത്തുന്നു.

\uhhhh- hhhh (4 ഹെക്സാഡെസിമൽ അക്കങ്ങൾ) കോഡ് ഉള്ള ഒരു പ്രതീകം കണ്ടെത്തുന്നു.

പതാകകൾ

റെഗുലർ എക്സ്പ്രഷൻ ഫ്ലാഗുകൾ ഉയർന്ന തലത്തിലുള്ള പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ നിയമങ്ങൾ വ്യക്തമാക്കുന്നു. സാധാരണ എക്‌സ്‌പ്രഷൻ വ്യാകരണത്തിൽ നിന്ന് വ്യത്യസ്തമായി, സ്ലാഷ് പ്രതീകങ്ങൾക്കിടയിലല്ല, രണ്ടാമത്തേതിന് ശേഷമായിരിക്കും ഫ്ലാഗുകൾ വ്യക്തമാക്കുന്നത്. IN ജാവാസ്ക്രിപ്റ്റ്മൂന്ന് പതാകകൾ പിന്തുണയ്ക്കുന്നു.

പതാക ഐപാറ്റേൺ തിരയൽ കേസ് സെൻസിറ്റീവ് ആയിരിക്കണമെന്നും ഫ്ലാഗ് ആയിരിക്കണമെന്നും സൂചിപ്പിക്കുന്നു ജി- തിരയൽ ആഗോളമായിരിക്കണം, അതായത്. സ്ട്രിംഗിലെ എല്ലാ പൊരുത്തങ്ങളും കണ്ടെത്തണം. പതാക എംമൾട്ടി-ലൈൻ മോഡിൽ ഒരു പാറ്റേൺ തിരയൽ നടത്തുന്നു. തിരയുന്ന സ്‌ട്രിംഗ് എക്‌സ്‌പ്രഷനിൽ പുതിയ ലൈനുകൾ അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, ഈ മോഡിൽ ആങ്കർ പ്രതീകങ്ങൾ ^, $ എന്നിവ, മുഴുവൻ സ്‌ട്രിംഗ് എക്‌സ്‌പ്രഷനിന്റെയും തുടക്കവും അവസാനവും പൊരുത്തപ്പെടുത്തുന്നതിന് പുറമേ, ഓരോന്നിന്റെയും തുടക്കവും അവസാനവും പൊരുത്തപ്പെടുത്തുന്നു. ടെക്സ്റ്റ് സ്ട്രിംഗ്. ഏത് കോമ്പിനേഷനിലും പതാകകൾ കൂട്ടിച്ചേർക്കാം.

സ്ട്രിംഗ് ക്ലാസ് രീതികൾ

റെഗുലർ എക്‌സ്‌പ്രഷനുകൾ ഉപയോഗിക്കുന്ന നാല് രീതികളെ സ്ട്രിംഗുകൾ പിന്തുണയ്ക്കുന്നു.

തിരയൽ () രീതി

ഇത് ഒരു സാധാരണ പദപ്രയോഗത്തെ ഒരു ആർഗ്യുമെന്റായി എടുക്കുകയും പൊരുത്തപ്പെടുന്ന സബ്‌സ്‌ട്രിംഗിന്റെ ആദ്യ പ്രതീകത്തിന്റെ സ്ഥാനം അല്ലെങ്കിൽ പൊരുത്തം കണ്ടെത്തിയില്ലെങ്കിൽ -1 നൽകുകയും ചെയ്യുന്നു. ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന കോൾ 4 തിരികെ നൽകും:

Var ഫലം = "JavaScript".search(/script/i); // 4

തിരയൽ() രീതിയിലേക്കുള്ള ആർഗ്യുമെന്റ് ഒരു സാധാരണ പദപ്രയോഗമല്ലെങ്കിൽ, അത് ആദ്യം RegExp കൺസ്ട്രക്റ്ററിലേക്ക് കൈമാറുന്നതിലൂടെ പരിവർത്തനം ചെയ്യപ്പെടും. തിരയൽ () രീതി പിന്തുണയ്ക്കുന്നില്ല ആഗോള തിരയൽപതാകയെ അവഗണിക്കുകയും ചെയ്യുന്നു ജിനിങ്ങളുടെ വാദത്തിൽ.

പകരം () രീതി

ഇത് ഒരു തിരയൽ, മാറ്റിസ്ഥാപിക്കൽ പ്രവർത്തനം നടത്തുന്നു. ഇത് അതിന്റെ ആദ്യ ആർഗ്യുമെന്റായി ഒരു റെഗുലർ എക്‌സ്‌പ്രഷനും രണ്ടാമത്തേതായി ഒരു റീപ്ലേസ്‌മെന്റ് സ്‌ട്രിംഗും എടുക്കുന്നു. ഈ രീതി നിർദ്ദിഷ്ട പാറ്റേണുമായി പൊരുത്തപ്പെടുന്നതിന് വിളിക്കുന്ന വരിയിൽ തിരയുന്നു. റെഗുലർ എക്‌സ്‌പ്രഷനിൽ g ഫ്ലാഗ് അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, റീപ്ലേസ്‌മെന്റ് സ്‌ട്രിംഗിൽ കാണുന്ന എല്ലാ പൊരുത്തങ്ങളെയും റീപ്ലേസ്() രീതി മാറ്റിസ്ഥാപിക്കുന്നു. അല്ലെങ്കിൽ, കണ്ടെത്തിയ ആദ്യ പൊരുത്തം മാത്രം മാറ്റിസ്ഥാപിക്കുന്നു.

പൊരുത്തം () രീതി

ഇത് ഒരു റെഗുലർ എക്‌സ്‌പ്രഷൻ അതിന്റെ ഏക ആർഗ്യുമെന്റായി എടുക്കുന്നു (അല്ലെങ്കിൽ അതിന്റെ ആർഗ്യുമെന്റിനെ RegExp() കൺസ്ട്രക്‌ടറിലേക്ക് കടത്തി ഒരു സാധാരണ എക്‌സ്‌പ്രഷനിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു) കൂടാതെ തിരയൽ ഫലങ്ങൾ അടങ്ങിയ ഒരു അറേ നൽകുന്നു. സാധാരണ എക്‌സ്‌പ്രഷനിലാണ് g ഫ്ലാഗ് സജ്ജീകരിച്ചിരിക്കുന്നതെങ്കിൽ, സ്‌ട്രിംഗിലുള്ള എല്ലാ പൊരുത്തങ്ങളുടെയും ഒരു ശ്രേണി ഈ രീതി നൽകുന്നു. ഉദാഹരണത്തിന്:

// തിരികെ നൽകും ["1", "2", "3"] var ഫലം = "1 പ്ലസ് 2 സമം 3".match(/\d+/g);

റെഗുലർ എക്‌സ്‌പ്രഷനിൽ g ഫ്ലാഗ് ഇല്ലെങ്കിൽ, മാച്ച്() രീതി ആഗോള തിരയൽ നടത്തില്ല; അത് ആദ്യ മത്സരത്തിനായി നോക്കുന്നു. എന്നിരുന്നാലും, രീതി ആഗോള തിരയൽ നടത്താത്തപ്പോൾ പോലും മാച്ച്() ഒരു അറേ നൽകുന്നു. ഈ സാഹചര്യത്തിൽ, അറേയുടെ ആദ്യ ഘടകം കണ്ടെത്തിയ സബ്‌സ്‌ട്രിംഗാണ്, ശേഷിക്കുന്ന എല്ലാ ഘടകങ്ങളും റെഗുലർ എക്‌സ്‌പ്രഷനിന്റെ ഉപവിഷ്‌കാരങ്ങളാണ്.

സ്പ്ലിറ്റ് () രീതി

ഈ രീതി, ആർഗ്യുമെന്റ് ഒരു ഡിലിമിറ്ററായി ഉപയോഗിച്ചുകൊണ്ട് സബ്‌സ്ട്രിംഗുകളുടെ ഒരു നിരയായി വിളിക്കപ്പെടുന്ന സ്ട്രിംഗിനെ വിഭജിക്കുന്നു. ഉദാഹരണത്തിന്:

"123,456,789".സ്പ്ലിറ്റ്(","); // മടങ്ങുക ["123","456","789"]

സ്പ്ലിറ്റ്() രീതിക്ക് ഒരു റെഗുലർ എക്‌സ്‌പ്രഷനും ഒരു ആർഗ്യുമെന്റായി എടുക്കാം. ഇത് രീതിയെ കൂടുതൽ ശക്തമാക്കുന്നു.

RegExp ഒബ്ജക്റ്റ്

RegExp() കൺസ്ട്രക്റ്റർ ഒന്നോ രണ്ടോ സ്ട്രിംഗ് ആർഗ്യുമെന്റുകൾ എടുത്ത് ഒരു പുതിയ RegExp ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുന്നു. കൺസ്‌ട്രക്‌ടറിലേക്കുള്ള ആദ്യ വാദം, റെഗുലർ എക്‌സ്‌പ്രെഷന്റെ ബോഡി അടങ്ങുന്ന ഒരു സ്ട്രിംഗ് ആണ്, അതായത്. അക്ഷരാർത്ഥത്തിൽ ഒരു സാധാരണ പദപ്രയോഗത്തിൽ സ്ലാഷ് പ്രതീകങ്ങൾക്കിടയിൽ ദൃശ്യമാകേണ്ട വാചകം. RegExp() എന്നതിലേക്കുള്ള രണ്ടാമത്തെ ആർഗ്യുമെന്റ് നഷ്‌ടമായേക്കാം. വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, അത് റെഗുലർ എക്സ്പ്രഷൻ ഫ്ലാഗുകളെ നിർവചിക്കുന്നു. ഇത് കഥാപാത്രങ്ങളിൽ ഒന്നായിരിക്കണം g, i, mഅല്ലെങ്കിൽ ഈ ചിഹ്നങ്ങളുടെ സംയോജനം.

RegExp പ്രോപ്പർട്ടികൾ

ഓരോ RegExp ഒബ്ജക്റ്റിനും അഞ്ച് ഗുണങ്ങളുണ്ട്:

• ഉറവിടം- റെഗുലർ എക്‌സ്‌പ്രഷനിലെ ടെക്‌സ്‌റ്റ് അടങ്ങുന്ന ഒരു വായന-മാത്രം സ്‌ട്രിംഗ്.
• ആഗോള- പതാകയുടെ സാന്നിധ്യം നിർണ്ണയിക്കുന്ന ഒരു വായന-മാത്രം ലോജിക്കൽ മൂല്യം ജിഒരു പതിവ് ഭാവത്തിൽ.
• അവഗണിക്കുക കേസ് ഐഒരു പതിവ് ഭാവത്തിൽ.
• മൾട്ടിലൈൻഫ്ലാഗ് ഉണ്ടോ എന്ന് നിർണ്ണയിക്കുന്ന റീഡ്-ഒൺലി ബൂളിയൻ മൂല്യമാണ് എംഒരു പതിവ് ഭാവത്തിൽ.
• അവസാന സൂചികവായിക്കാനും എഴുതാനും കഴിയുന്ന ഒരു പൂർണ്ണസംഖ്യയാണ്. ഒരു ഫ്ലാഗ് ഉള്ള ടെംപ്ലേറ്റുകൾക്കായി ജിഈ പ്രോപ്പർട്ടിയിൽ അടുത്ത തിരയൽ ആരംഭിക്കേണ്ട വരിയിലെ സ്ഥാന നമ്പർ അടങ്ങിയിരിക്കുന്നു.

RegExp രീതികൾ

പാറ്റേൺ പൊരുത്തപ്പെടുത്തൽ നടത്തുന്ന രണ്ട് രീതികൾ RegExp ഒബ്ജക്റ്റുകൾ നിർവചിക്കുന്നു.

exec() രീതി

exec() രീതി നിർദ്ദിഷ്ട സ്‌ട്രിങ്ങിനുള്ള റെഗുലർ എക്‌സ്‌പ്രഷൻ എക്‌സിക്യൂട്ട് ചെയ്യുന്നു, അതായത്. ഒരു സ്ട്രിംഗിൽ ഒരു പൊരുത്തം തിരയുന്നു. പൊരുത്തമൊന്നും കണ്ടെത്തിയില്ലെങ്കിൽ, രീതി അസാധുവായി നൽകുന്നു. എന്നിരുന്നാലും, ഒരു പൊരുത്തം കണ്ടെത്തിയാൽ, അത് ഫ്ലാഗ് ഇല്ലാതെ തിരയുന്നതിനുള്ള മാച്ച്() രീതി നൽകുന്ന അറേയുടെ അതേ അറേ നൽകുന്നു. ജി.

അറേയുടെ സീറോ എലമെന്റിൽ റെഗുലർ എക്‌സ്‌പ്രഷനുമായി പൊരുത്തപ്പെടുന്ന സ്‌ട്രിംഗ് അടങ്ങിയിരിക്കുന്നു, കൂടാതെ എല്ലാം തുടർന്നുള്ള ഘടകങ്ങൾ- എല്ലാ സബ്‌എക്‌സ്‌പ്രഷനുകൾക്കും അനുയോജ്യമായ സബ്‌സ്‌ട്രിംഗുകൾ. മാച്ച്(), പതിവ് എക്‌സ്‌പ്രഷനിലെ ഫ്ലാഗിന്റെ സാന്നിധ്യത്തെ ആശ്രയിക്കാത്ത ഘടനയുള്ള ഒരു അറേ എക്‌സിക്() രീതി നൽകുന്നു. ജി.

അതേ റെഗുലർ എക്‌സ്‌പ്രഷനിൽ എക്‌സിക്() എന്നതിനെ രണ്ടാം തവണ വിളിക്കുമ്പോൾ, ലാസ്റ്റ് ഇൻഡക്‌സ് പ്രോപ്പർട്ടിയിൽ വ്യക്തമാക്കിയിരിക്കുന്ന പ്രതീകത്തിൽ അത് തിരയൽ ആരംഭിക്കുന്നു. exec() ഒരു പൊരുത്തം കണ്ടെത്തിയില്ലെങ്കിൽ, ലാസ്റ്റ് ഇൻഡക്സ് പ്രോപ്പർട്ടി 0 ആയി സജ്ജീകരിച്ചിരിക്കുന്നു.

പരീക്ഷണ രീതി

ഇത് ഒരു സ്‌ട്രിംഗ് എടുക്കുകയും സ്‌ട്രിംഗ് പതിവ് എക്‌സ്‌പ്രഷനുമായി പൊരുത്തപ്പെടുന്നെങ്കിൽ ശരി തിരികെ നൽകുകയും ചെയ്യുന്നു:

Var പാറ്റേൺ = /java/i; pattern.test("JavaScript"); // സത്യമായി മടങ്ങുക

കോളിംഗ് ടെസ്റ്റ്() എന്നത് കോളിംഗ് എക്‌സിക്()ന് തുല്യമാണ്, ഇത് എക്‌സിക്() ശൂന്യമല്ലാത്ത മറ്റെന്തെങ്കിലും നൽകുകയാണെങ്കിൽ അത് ശരിയാണെന്ന് നൽകുന്നു. ഇക്കാരണത്താൽ, ഒരു ഗ്ലോബൽ റെഗുലർ എക്‌സ്‌പ്രഷനിൽ വിളിക്കുമ്പോൾ എക്‌സിക്() രീതി പോലെ തന്നെ ടെസ്റ്റ്() രീതിയും പ്രവർത്തിക്കുന്നു: ലാസ്റ്റ് ഇൻഡക്‌സ് പ്രോപ്പർട്ടി വ്യക്തമാക്കിയ സ്ഥാനത്ത്, അത് ഒരു പൊരുത്തം കണ്ടെത്തുകയാണെങ്കിൽ, അത് നിർദ്ദിഷ്ട സ്‌ട്രിംഗിനായി തിരയാൻ തുടങ്ങുന്നു. , അവസാന ഇൻഡക്സ് പ്രോപ്പർട്ടി, കണ്ടെത്തിയ പൊരുത്തത്തിന് തൊട്ടടുത്തുള്ള പ്രതീക സ്ഥാന നമ്പറിലേക്ക് സജ്ജീകരിക്കുന്നു.

ഒരു ടെംപ്ലേറ്റ് എഴുതുന്നു

ഒരു റെഗുലർ എക്സ്പ്രഷൻ പാറ്റേണിൽ /ab*c/ അല്ലെങ്കിൽ /അധ്യായം (\d+)\.\d*/ പോലെയുള്ള പതിവ് പ്രതീകങ്ങൾ അല്ലെങ്കിൽ /abc/ പോലുള്ള പതിവ്, പ്രത്യേക പ്രതീകങ്ങളുടെ കോമ്പിനേഷനുകൾ അടങ്ങിയിരിക്കുന്നു. അവസാനത്തെ ഉദാഹരണത്തിൽ പരാൻതീസിസുകൾ ഉൾപ്പെടുന്നു, അവ "മെമ്മറി മെക്കാനിസം" ആയി ഉപയോഗിക്കുന്നു. ഭാവിയിലെ ഉപയോഗത്തിനായി ടെംപ്ലേറ്റിന്റെ ഈ ഭാഗത്തിന്റെ പൊരുത്തം ഓർമ്മിക്കപ്പെടുന്നു.

ലളിതമായ ടെംപ്ലേറ്റുകൾ ഉപയോഗിക്കുന്നു

വാചകത്തിൽ നേരിട്ടുള്ള പൊരുത്തങ്ങൾ കണ്ടെത്താൻ ലളിതമായ പാറ്റേണുകൾ ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, പാറ്റേൺ /abc/ ഒരു സ്‌ട്രിംഗിലെ പ്രതീകങ്ങളുടെ സംയോജനവുമായി പൊരുത്തപ്പെടുന്നത് 'abc' പ്രതീകങ്ങൾ ഒരുമിച്ച് ഒരേ ക്രമത്തിൽ ദൃശ്യമാകുമ്പോൾ മാത്രം.

JavaScript-ൽ, റെഗുലർ എക്‌സ്‌പ്രഷനുകളെ RegExp ഒബ്‌ജക്‌റ്റുകൾ പ്രതിനിധീകരിക്കുന്നു. RegExp ഒബ്‌ജക്റ്റുകൾ RegExp() കൺസ്ട്രക്‌റ്റർ ഉപയോഗിച്ച് സൃഷ്‌ടിക്കാൻ കഴിയും, എന്നാൽ മിക്കപ്പോഴും അവ ഒരു പ്രത്യേക ലിറ്ററൽ വാക്യഘടന ഉപയോഗിച്ചാണ് സൃഷ്‌ടിക്കുന്നത്. സ്ട്രിംഗ് ലിറ്ററലുകൾ ഉദ്ധരണി ചിഹ്നങ്ങളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന പ്രതീകങ്ങളായി വ്യക്തമാക്കിയിരിക്കുന്നതുപോലെ, പതിവ് എക്സ്പ്രഷൻ ലിറ്ററലുകൾ ഒരു സ്ലാഷ് ജോഡിയിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന പ്രതീകങ്ങളായി വ്യക്തമാക്കുന്നു / .

/പാറ്റേൺ/പുതിയ RegExp("പാറ്റേൺ"[, തിരയൽ ഓപ്ഷനുകൾ]) ഫ്ലാഗ് ചെയ്യുന്നു

മാതൃക- തിരയലിനുള്ള ഒരു സാധാരണ പദപ്രയോഗം (പിന്നീട് മാറ്റിസ്ഥാപിക്കുന്നതിൽ കൂടുതൽ), ഒപ്പം ഫ്ലാഗുകൾ - g (ആഗോള തിരയൽ), i (കേസ് പ്രധാനമല്ല), m (മൾട്ടി-ലൈൻ തിരയൽ) എന്നീ പ്രതീകങ്ങളുടെ ഏതെങ്കിലും സംയോജനത്തിന്റെ ഒരു സ്ട്രിംഗ്. ആദ്യ രീതി പലപ്പോഴും ഉപയോഗിക്കുന്നു, രണ്ടാമത്തേത് - ചിലപ്പോൾ. ഉദാഹരണത്തിന്, അത്തരം രണ്ട് കോളുകൾ തുല്യമാണ്.

തിരയൽ ഓപ്ഷനുകൾ

ഒരു സാധാരണ പദപ്രയോഗം സൃഷ്ടിക്കുമ്പോൾ, നമുക്ക് വ്യക്തമാക്കാം അധിക ഓപ്ഷനുകൾതിരയുക

JavaScript റെഗുലർ എക്സ്പ്രഷനുകളിലെ പ്രതീകങ്ങൾ

ജാവാസ്ക്രിപ്റ്റിൽ റെഗുലർ എക്സ്പ്രഷനുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നു

ജാവാസ്ക്രിപ്റ്റിലെ പതിവ് എക്സ്പ്രഷനുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നത് സ്ട്രിംഗ് ക്ലാസിന്റെ രീതികൾ വഴി നടപ്പിലാക്കുന്നു

exec(regexp) - ഒരു സ്ട്രിംഗിൽ എല്ലാ പൊരുത്തങ്ങളും (സാധാരണ പാറ്റേണിലെ എൻട്രികൾ) കണ്ടെത്തുന്നു. ഒരു അറേ നൽകുകയും (ഒരു പൊരുത്തം ഉണ്ടെങ്കിൽ) regexp പ്രോപ്പർട്ടി അപ്ഡേറ്റ് ചെയ്യുകയും ചെയ്യുന്നു, അല്ലെങ്കിൽ ഒന്നും കണ്ടെത്തിയില്ലെങ്കിൽ അസാധുവാക്കുക. g മോഡിഫയർ ഉപയോഗിച്ച് - ഓരോ തവണയും ഈ ഫംഗ്‌ഷൻ വിളിക്കുമ്പോൾ, മുമ്പത്തെ ഒന്ന് കണ്ടെത്തിയതിന് ശേഷമുള്ള അടുത്ത പൊരുത്തം അത് തിരികെ നൽകും - ഇത് അവസാന തിരയലിന്റെ ഒരു ഓഫ്‌സെറ്റ് സൂചിക നിലനിർത്തിക്കൊണ്ട് നടപ്പിലാക്കുന്നു.

പൊരുത്തം (regexp) - ഒരു പാറ്റേൺ ഉപയോഗിച്ച് ഒരു സ്ട്രിംഗിന്റെ ഭാഗം കണ്ടെത്തുക. g മോഡിഫയർ വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, മാച്ച്() എല്ലാ പൊരുത്തങ്ങളുടെയും ഒരു അറേ അല്ലെങ്കിൽ ശൂന്യം (ശൂന്യമായ അറേയ്ക്ക് പകരം) നൽകുന്നു. g മോഡിഫയർ ഇല്ലാതെ, ഈ ഫംഗ്ഷൻ exec();

test(regexp) - ഒരു പാറ്റേൺ പൊരുത്തപ്പെടുത്തുന്നതിനായി ഫംഗ്ഷൻ ഒരു സ്ട്രിംഗ് പരിശോധിക്കുന്നു. പൊരുത്തമുണ്ടെങ്കിൽ ശരിയും പൊരുത്തമില്ലെങ്കിൽ തെറ്റും നൽകുന്നു.

സ്പ്ലിറ്റ്(regexp) - ആർഗ്യുമെന്റ് ഒരു ഡിലിമിറ്ററായി ഉപയോഗിച്ച് സബ്‌സ്ട്രിംഗുകളുടെ ഒരു നിരയിലേക്ക് വിളിക്കുന്ന സ്ട്രിംഗിനെ വിഭജിക്കുന്നു.

മാറ്റിസ്ഥാപിക്കുക(regexp, mix) - രീതി ടെംപ്ലേറ്റിന് (പതിവ് എക്സ്പ്രഷൻ) അനുസൃതമായി പരിഷ്കരിച്ച ഒരു സ്ട്രിംഗ് നൽകുന്നു. regexp-ലേക്കുള്ള ആദ്യ പാരാമീറ്റർ ഒരു സാധാരണ എക്സ്പ്രഷൻ എന്നതിലുപരി ഒരു സ്ട്രിംഗ് ആകാം. g മോഡിഫയർ ഇല്ലാതെ, ലൈനിലെ രീതി ആദ്യ സംഭവത്തെ മാത്രം മാറ്റിസ്ഥാപിക്കുന്നു; മോഡിഫയർ g ഉപയോഗിച്ച് - സംഭവിക്കുന്നു ആഗോള മാറ്റിസ്ഥാപിക്കൽ, അതായത്. തന്നിരിക്കുന്ന വരിയിലെ എല്ലാ സംഭവങ്ങളും മാറ്റുന്നു. മിക്സ് - റീപ്ലേസ്‌മെന്റ് ടെംപ്ലേറ്റ്, ഒരു സ്ട്രിംഗ്, റീപ്ലേസ്‌മെന്റ് ടെംപ്ലേറ്റ്, ഫംഗ്‌ഷൻ (ഫംഗ്ഷൻ നാമം) എന്നിവയുടെ മൂല്യങ്ങൾ സ്വീകരിക്കാൻ കഴിയും.

മാറ്റിസ്ഥാപിക്കുന്ന സ്ട്രിംഗിലെ പ്രത്യേക പ്രതീകങ്ങൾ

ഫംഗ്ഷൻ വഴി മാറ്റിസ്ഥാപിക്കൽ

രണ്ടാമത്തെ പരാമീറ്ററായി നിങ്ങൾ ഒരു ഫംഗ്ഷൻ വ്യക്തമാക്കുകയാണെങ്കിൽ, ഓരോ പൊരുത്തത്തിനും അത് എക്സിക്യൂട്ട് ചെയ്യപ്പെടും. ഒരു ഫംഗ്‌ഷന് ചലനാത്മകമായി ഒരു സബ്‌സ്റ്റിറ്റ്യൂഷൻ സ്‌ട്രിംഗ് സൃഷ്‌ടിക്കാനും തിരികെ നൽകാനും കഴിയും. ഫംഗ്‌ഷന്റെ ആദ്യ പാരാമീറ്റർ കണ്ടെത്തിയ സബ്‌സ്ട്രിംഗ് ആണ്. മാറ്റിസ്ഥാപിക്കാനുള്ള ആദ്യ ആർഗ്യുമെന്റ് ഒരു RegExp ഒബ്‌ജക്റ്റ് ആണെങ്കിൽ, അടുത്ത n പരാമീറ്ററുകളിൽ നെസ്റ്റഡ് പരാൻതീസിസ് പൊരുത്തങ്ങൾ അടങ്ങിയിരിക്കുന്നു. അവസാനത്തെ രണ്ട് പാരാമീറ്ററുകൾ പൊരുത്തം സംഭവിച്ച വരിയിലെ സ്ഥാനവും വരി തന്നെയുമാണ്.