BAM! BOMS!

", "", "div", " class="test""]

erstatte funksjon

str.replace(regexp, newSubStr|function)

• regexp - reg. uttrykk;
• newSubStr - strengen som det funnet uttrykket i teksten endres til;
• funksjon - kalt for hvert samsvar funnet med en variabel liste over parametere (husk at et globalt søk i en streng finner alle forekomster av et mønstertreff).

Returverdien til denne funksjonen fungerer som en erstatning.

Funksjonsparametere:

• 1 - Komplett matchende delstreng.
• 2 - Betydningen av parentesgrupper (fikseringer).
• 3 - Indeks (posisjon) for kampen i kildestrengen.
• 4 - Kildestreng.

Metoden endrer ikke kallestrengen, men returnerer en ny etter å ha erstattet samsvarene. For å utføre et globalt søk og erstatte, bruk regexp med g-flagget.

"GHGHGHGTTTT".replace(//g,"K"); //"KKKKKKKKKKKK"

Javascript

function upLetter(allStr,letter) ( return letter.toUpperCase(); ) var res = "border-top-width".replace(/-(\w)/g, upLetter); console.log(res); //borderTopWidth

JavaScript - Leksjon 14. Regelmessige uttrykk

Temaet regulære uttrykk er ganske omfattende og kan ikke dekkes i én leksjon, men hensikten med leksjonene våre er å gi deg en grunnleggende forståelse av javascript-språket og dets muligheter, derfor er det umulig å ignorere regulære uttrykk.

La oss først finne ut hva det er.
Vanlig uttrykk- dette er en instruksjon som beskriver i et spesialutviklet språk (RegExp) loven om "likhet" til den ønskede strengen med mønsteret.

Hva er den til? For eksempel:

• For å organisere et søk etter noe i teksten.
• For å erstatte en del av understrenger med andre.
• For å sjekke riktigheten av brukerinndata (du har sannsynligvis kommet over en situasjon mer enn én gang da du skrev inn e-postadressen din i et eller annet skjema og mottok en feilmelding som "Ugyldig e-post").

Vi vil ikke gå inn på detaljer, men la oss se på hvordan du setter regulære uttrykk. Det er to måter, i denne leksjonen vil vi se på en (skaping i bokstavelig notasjon):

Var p=/mønster/flagg;

Hvor
mønster- et mønster er grunnlaget for et regulært uttrykk som definerer strengsamsvarskriterier. Består av bokstavelige og metategn.
flagg- flagg (modifikatorer) som spesifiserer ekstra malmatchende parametere.

Var par=/+/i;

Her + - en mal som bokstavelig talt betyr følgende "hvilket som helst antall tall og bokstaver 1 eller flere ganger" (vi ser hvordan du angir en mal nedenfor).

Jeg

For å gjøre det klarere hva vi snakker om, la oss se på et eksempel. La oss anta at vi har et skjema der brukeren skriver inn e-post og passord. Vi ønsker at når du klikker på "Registrer deg"-knappen, sjekkes inndataene for riktighet.

HTML-sidekoden vil være som følger:

Javascript regulære uttrykk

Registreringsskjema

Så hva skal funksjonen gjøre? prov_adresse()? For å begynne trenger vi to variabler der vi vil plassere verdiene som er lagt inn av brukeren:

funksjon prov_adress(obj) ( var adr=obj.mail.value; var par=obj.pas.value; )

Nå må vi sette mønstre (regulære uttrykk) som vi skal sammenligne det brukeren skrev inn med. Her vil jeg bare gi dem; vi snakker om hvordan du komponerer dem senere:

function prov_adress(obj) ( var adr=obj.mail.value; var par=obj.pas.value; var adr_pattern=/+@+\.(2,5)/i; var par_pattern=/+/i; )

Nå sjekker vi for mønstertilpasning. For å gjøre dette vil vi bruke metoden test gjenstand RegExp:

function prov_adress(obj) ( var adr=obj.mail.value; var par=obj.pas.value; var adr_pattern=/+@+\.(2,5)/i; var par_pattern=/+/i; var prov=adr_pattern.test(adr); var prov1=par_pattern.test(par); )

Linje adr_pattern.test(adr) betyr følgende: se etter eksistens i en streng adr sekvens som samsvarer med det regulære uttrykket adr_pattern. Metode test returnerer en boolsk verdi (sann eller usann).

Alt vi trenger å gjøre er å angi i funksjonen vår hva vi skal gjøre i tilfelle en vellykket (eller mislykket) sjekk:

function prov_adress(obj) ( var adr=obj.mail.value; var par=obj.pas.value; var adr_pattern=/+@+\.(2,5)/i; var par_pattern=/+/i; var prov=adr_pattern.test(adr); var prov1=par_pattern.test(par); if (prov==true && prov1==true) (alert("Du er registrert!"); ) else ( alert(" De angitte dataene er feil !"); ) )

Ferdig, jeg håper du forstår essensen av det vi gjør. Men før vi sjekker driften av skriptet vårt, la oss se hva våre regulære uttrykk består av.

La oss ta et vanlig uttrykk for passordet vårt - /+/i:

• /+/ - en mal der:
  • 0-9 - hvilket som helst nummer.
  
  
  • a-z- enhver liten bokstav fra a til å.
  
  
  • - hakeparenteser betyr at mønsteret kan inneholde noen av bokstavene som er oppført i dem (i vårt tilfelle tall og små bokstaver)
  
  
  • + - indikerer at denne delen av mønsteret (dvs. det som står i hakeparenteser) kan gjentas en eller flere ganger.
  
  


• Jeg- et flagg som indikerer at store og små bokstaver ikke spiller noen rolle.

Med andre ord, vårt regulære uttrykk spesifiserer at passordet kan inneholde et hvilket som helst antall tall og bokstaver 1 eller flere ganger (dvs. det kan bestå av ett tall, en bokstav, mange tall, mange bokstaver, tall og bokstaver) .

Hvis brukeren for eksempel skriver inn "2", "a3b" eller "leopard" i passordfeltet, vil et slikt passord anses som riktig. Og hvis han skriver inn "ab&s" eller "24?", vil et slikt passord ikke anses som riktig, fordi den inneholder spesialtegn, og vi tillot dem ikke i det regulære uttrykket.

Jeg håper det nå er klart hvordan og hvorfor du kan bruke regulære uttrykk, alt som gjenstår er å lære prinsippene for komposisjonen deres. Strengt tatt kommer oppgaven med å komponere et regulært uttrykk ned på å lage malen. Og malen, som du husker, kan bestå av bokstaver og metategn.

La oss starte med det enkleste - bokstavelige ord:

• Hvert av disse symbolene representerer seg selv. For eksempel, /abc/ - bare strengen "abc" samsvarer med dette mønsteret.


• a-z- alle små bokstaver fra a til å. For eksempel, /a-z/ - dette mønsteret samsvarer med 26 strenger: "a", "b", "c"... "z"


• A-Å- alle store bokstaver fra A til Å.


• 0-9 - alle tall.

Hvis vi vil indikere at det kan være flere tall eller bokstaver, må vi bruke kontrolltegn:

• * - indikerer at tegnet (eller en del av mønsteret, hvis det er omsluttet av hakeparenteser) kan gjentas 0 eller flere ganger. For eksempel betyr /ab*c/ - at linjen begynner med tegnet a, så kan det være et hvilket som helst antall b-tegn, etterfulgt av tegnet c. De. disse kan for eksempel være følgende strenger: "ac", "abc", "abbbbbbc", etc.


• + - indikerer at tegnet (eller en del av mønsteret, hvis det er omsluttet av hakeparenteser) kan gjentas 1 eller flere ganger. For eksempel betyr /ab+c/ - at linjen begynner med tegnet a, så kan det være et hvilket som helst antall b-tegn (men ikke mindre enn 1), etterfulgt av tegnet c. De. disse kan for eksempel være følgende strenger: "abc", "abbbbbbc", etc.


• . - indikerer at dette stedet kan inneholde et hvilket som helst enkelt tegn unntatt et linjeskifttegn. For eksempel, for mønsteret /ab.c/ er følgende strenger sammenlignbare: "ab6c", "abxc", "ab=c", etc.


• ? - indikerer at tegnet (eller en del av mønsteret, hvis det er omsluttet av hakeparenteser) kan gjentas 0 eller 1 gang. For eksempel betyr /ab?c/ - at linjen begynner med tegnet a, så kan det være eller ikke være ett tegn b, etterfulgt av tegnet c. De. disse kan være følgende strenger: "ac", "abc"


• (n)- indikerer at tegnet (eller en del av mønsteret, hvis det er omsluttet av hakeparenteser) kan gjentas nøyaktig n ganger. For eksempel betyr /ab(3)c/ - at linjen begynner med tegnet a, så er det 3 tegn b, etterfulgt av tegnet c. De. dette vil være strengen "abbbc".


• (n,)- indikerer at tegnet (eller en del av mønsteret, hvis det er omsluttet av hakeparenteser) kan gjentas n eller flere ganger. For eksempel betyr /ab(3,)c/ - at linjen begynner med tegnet a, så er det 3 eller flere tegn b, etterfulgt av tegnet c. De. disse kan være følgende strenger: "abbbc", "abbbbbbbc", etc.


• (n, m)- indikerer at tegnet (eller en del av mønsteret, hvis det er omsluttet av hakeparenteser) kan gjentas n til m ganger. For eksempel betyr /ab(1,3)c/ - at linjen begynner med tegnet a, deretter er det 1 til 3 tegn b, etterfulgt av tegnet c. De. disse kan være følgende strenger: "abc", "abbc", "abbc".


• - et slikt mønster kan sammenlignes med ethvert enkelt tegn som tilhører settet definert i parentes. Et sett spesifiseres ved en oppregning eller ved å spesifisere et område. For eksempel kan mønsteret // matches av følgende strenger: "a", "b", "c".


• [^] - et slikt mønster kan sammenlignes med ethvert enkelt tegn som ikke tilhører settet definert i parentes. For eksempel kan mønsteret /[^abc]/ matche strengene: "f", "x", "Z", men kan ikke matche strengene: "a", "b", "c".


• ^ - indikerer at tegnene er sammenlignbare med begynnelsen av linjen. For eksempel kan mønsteret /^abc/ matche strengene: "abcd", "abcfh", men kan ikke matche strengene: "dabc", "cbabc", etc.


• $ - indikerer at tegnene samsvarer med slutten av strengen. For eksempel kan mønsteret /abc$/ matche strengene: "dabc", "fhabc", men kan ikke matche strengene: "abcd", "abccb", etc.


• | - indikerer flere alternative mønstre. For eksempel vil mønsteret /ab|c/ samsvare med følgende strenger: "ab" og "c".


• \ - tjener til å unnslippe spesialtegn, dvs. en omvendt skråstrek før et tegn indikerer at det skal tolkes som spesielt. For eksempel:
  • \d- samsvarer med et hvilket som helst tall fra 0 til 9.
  
  
  • \D- alt stemmer unntatt nummeret.
  
  
  • \s- tilsvarer et mellomrom.
  
  
  • \S- matcher alt unntatt et mellomrom.
  
  
  • \w- samsvarer med en bokstav, tall eller understrek.
  
  
  • \W- samsvarer med alt unntatt en bokstav, tall eller understrek.
  
  

For eksempel vil mønsteret /x\d\d/ samsvare med strengene: "x01", "x25", etc., men vil ikke samsvare med strengene: "A15", "x0A"...

Omvendt skråstrek brukes også til å gjøre en spesiell karakter bokstavelig. For eksempel, hvis vi trenger å finne strengen "a*b", så spesifiserer vi følgende mønster /a\*b/.

Ved å bruke bokstavene og metategnene ovenfor kan du lage alle mønstre du liker (tenk regulære uttrykk). La oss for eksempel se hva vi skrev for e-postmalen i vårt eksempel:

Var adr_pattern=/+@+\.(2,5)/i;

Så vi spesifiserte at e-postadressen har tall, bokstaver og understrek 1 eller flere ganger, etterfulgt av @, deretter tall, bokstaver og understrek igjen 1 eller flere ganger, deretter et punktum etterfulgt av bokstaver fra 2 til 5 ganger. Omtrent slik ser e-postadresser ut.

Når du nå vet hva vi spesifiserte i prøven, kan du sjekke eksemplets operasjon:

Noen mennesker, når de står overfor et problem, tenker: "Å, jeg skal bruke vanlige uttrykk." Nå har de to problemer.
Jamie Zawinski

Yuan-Ma sa: «Det krever mye kraft å skjære tre på tvers av trefibrene. Det krever mye kode å programmere på tvers av problemstrukturen.
Master Yuan-Ma, "Book of Programming"

Programmeringsverktøy og -teknikker overlever og sprer seg på en kaotisk evolusjonær måte. Noen ganger er det ikke de vakre og briljante som overlever, men rett og slett de som fungerer godt nok på sitt felt – for eksempel hvis de integreres i en annen vellykket teknologi.

I dette kapittelet skal vi diskutere et slikt verktøy - regulære uttrykk. Dette er en måte å beskrive mønstre i strengdata. De lager et lite, frittstående språk som er inkludert i JavaScript og mange andre språk og verktøy.

De vanlige timeplanene er både veldig merkelige og ekstremt nyttige. Syntaksen deres er kryptisk og JavaScript-programmeringsgrensesnittet er klønete. Men det er et kraftig verktøy for å utforske og manipulere strenger. Når du forstår dem, vil du bli en mer effektiv programmerer.

Lage et regulært uttrykk

Vanlig – objekttype. Den kan opprettes ved å ringe RegExp-konstruktøren, eller ved å skrive ønsket mal, omgitt av skråstreker.

Var re1 = new RegExp("abc"); var re2 = /abc/;

Begge disse regulære uttrykkene representerer det samme mønsteret: tegnet "a" etterfulgt av tegnet "b" etterfulgt av tegnet "c".

Hvis du bruker RegExp-konstruktøren, skrives mønsteret som en vanlig streng, så alle reglene angående skråstreker gjelder.

Den andre oppføringen, der mønsteret er mellom skråstreker, behandler skråstrek annerledes. For det første, siden mønsteret ender med en skråstrek, må vi sette en skråstrek før skråstreken fremover som vi ønsker å inkludere i mønsteret vårt. I tillegg vil omvendte skråstreker som ikke er en del av spesialtegn som \n bli bevart (i stedet for ignorert som i strenger), og vil endre betydningen av mønsteret. Noen tegn, som spørsmålstegnet eller pluss, har en spesiell betydning i regulære uttrykk, og skal du finne et slikt tegn, må det også innledes med en omvendt skråstrek.

Var eighteenPlus = /eighteen\+/;

For å vite hvilke tegn som må innledes med en skråstrek, må du lære en liste over alle spesialtegn i regulære uttrykk. Dette er foreløpig ikke mulig, så hvis du er i tvil, sett bare en skråstrek foran et tegn som ikke er en bokstav, tall eller mellomrom.

Ser etter treff

Gjengangere har flere metoder. Den enkleste er test. Hvis du sender den en streng, vil den returnere en boolsk verdi som indikerer om strengen inneholder en forekomst av det gitte mønsteret.

Console.log(/abc/.test("abcde")); // → true console.log(/abc/.test("abxde")); // → usant

En vanlig sekvens som kun består av ikke-spesialtegn er ganske enkelt en sekvens av disse tegnene. Hvis abc er hvor som helst i linjen vi tester (ikke bare i begynnelsen), vil testen returnere sann.

Ser etter et sett med karakterer

Du kan også finne ut om en streng inneholder abc ved å bruke indexOf. Vanlige mønstre lar deg gå lenger og skape mer komplekse mønstre.

La oss si at vi må finne et hvilket som helst tall. Når vi setter et sett med tegn i hakeparenteser i regulært uttrykk, betyr det at den delen av uttrykket samsvarer med alle tegnene i parentesene.

Begge uttrykkene er i linjer som inneholder et tall.

Console.log(//.test("i 1992")); // → true console.log(//.test("i 1992")); // → sant

I hakeparenteser brukes en bindestrek mellom to tegn for å spesifisere en rekke tegn, der sekvensen er spesifisert av Unicode-kodingen. Tegnene fra 0 til 9 er der bare på rad (koder fra 48 til 57), så det fanger dem alle og matcher et hvilket som helst tall.

Flere tegngrupper har egne innebygde forkortelser.

\d Hvilket som helst tall
\w Alfanumerisk tegn
\s Mellomrom (mellomrom, tabulator, ny linje osv.)
\D ikke et tall
\W er ikke et alfanumerisk tegn
\S er ikke et mellomrom
. alle tegn unntatt linjeskift

Dermed kan du angi dato- og klokkeslettformat som 01/30/2003 15:20 med følgende uttrykk:

Var dateTime = /\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")); // → usant

Ser forferdelig ut, ikke sant? Det er for mange skråstreker, noe som gjør mønsteret vanskelig å forstå. Vi forbedrer det litt senere.

Omvendt skråstrek kan også brukes i firkantede parenteser. For eksempel betyr [\d.] et hvilket som helst tall eller punktum. Legg merke til at perioden innenfor hakeparentesene mister sin spesielle betydning og blir rett og slett et punktum. Det samme gjelder andre spesialtegn, for eksempel +.

Du kan invertere et sett med tegn - det vil si at du må finne et hvilket som helst tegn bortsett fra de som er i settet - ved å plassere et ^-tegn rett etter den åpne hakeparentesen.

Var notBinary = /[^01]/; console.log(notBinary.test("1100100010100110")); // → falsk console.log(notBinary.test("1100100010200110")); // → sant

Repeterende deler av malen

Vi vet hvordan vi finner ett tall. Hva om vi trenger å finne hele tallet - en sekvens av ett eller flere siffer?

Hvis du setter et +-tegn etter noe i den vanlige rekkefølgen, vil dette bety at dette elementet kan gjentas mer enn én gang. /\d+/ betyr ett eller flere sifre.

Console.log(/"\d+"/.test(""123"")); // → true console.log(/"\d+"/.test("""")); // → false console.log(/"\d*"/.test(""123"")); // → true console.log(/"\d*"/.test("""")); // → sant

Stjernen * har nesten samme betydning, men den lar mønsteret forekomme null ganger. Hvis noe blir etterfulgt av en stjerne, hindrer det aldri mønsteret fra å være i linjen - det vises bare der null ganger.

Et spørsmålstegn gjør en del av mønsteret valgfritt, noe som betyr at det kan forekomme null eller én gang. I følgende eksempel kan tegnet u vises, men mønsteret samsvarer selv når det ikke gjør det.

Var nabo = /neighbou?r/; console.log(neighbor.test("nabo")); // → true console.log(neighbor.test("nabo")); // → sant

Krøllete seler brukes til å spesifisere nøyaktig antall ganger et mønster må forekomme. (4) etter et element betyr at det må vises 4 ganger på linjen. Du kan også angi et gap: (2,4) betyr at elementet må forekomme minst 2 og ikke mer enn 4 ganger.

En annen versjon av dato- og klokkeslettformatet, der dager, måneder og timer med ett eller to sifre er tillatt. Og den er også litt mer lesbar.

Var datoTid = /\d(1,2)-\d(1,2)-\d(4) \d(1,2):\d(2)/; console.log(dateTime.test("30-1-2003 8:45")); // → sant

Du kan bruke åpne mellomrom ved å utelate ett av tallene. (,5,) betyr at mønsteret kan forekomme fra null til fem ganger, og (5,) betyr fra fem eller flere.

Gruppering av underuttrykk

For å bruke * eller + operatorene på flere elementer samtidig, kan du bruke parenteser. Den delen av det regulære uttrykket i parentes regnes som ett element fra operatørenes synspunkt.

Var cartoonCrying = /boo+(hoo+)+/i; console.log(cartoonCrying.test("Boohoooohoohooo")); // → sant

Første og andre pluss gjelder kun for andre o'er i boo og hoo. Det tredje + refererer til hele gruppen (hoo+), som finner en eller flere slike sekvenser.

Bokstaven i på slutten av uttrykket gjør det regulære uttrykket ufølsomt for store og små bokstaver - slik at B stemmer overens med b.

Kamper og grupper

Testmetoden er den enkleste metoden for å sjekke regulære uttrykk. Den forteller deg bare om en match ble funnet eller ikke. Gjengangere har også en exec-metode, som vil returnere null hvis ingenting ble funnet, og ellers returnere et objekt med informasjon om kampen.

Var match = /\d+/.exec("en to 100"); console.log(match); // → ["100"] console.log(match.index); // → 8

Objektet som returneres av exec har en indeksegenskap, som inneholder nummeret på tegnet som samsvaret skjedde fra. Generelt ser objektet ut som en rekke strenger, der det første elementet er strengen som ble sjekket for samsvar. I vårt eksempel vil dette være tallrekkefølgen vi lette etter.

Strenger har en matchmetode som fungerer omtrent på samme måte.

Console.log("en to 100".match(/\d+/)); // → ["100"]

Når et regulært uttrykk inneholder underuttrykk gruppert i parentes, vil teksten som samsvarer med disse gruppene også vises i matrisen. Det første elementet er alltid en komplett match. Den andre er delen som samsvarte med den første gruppen (den hvis parentes oppstod først), deretter den andre gruppen, og så videre.

Var quotedText = /"([^"]*)"/; console.log(quotedText.exec("hun sa "hei"")); // → [""hei"", "hei"]

Når en gruppe ikke blir funnet i det hele tatt (for eksempel hvis den etterfølges av et spørsmålstegn), er dens posisjon i matrisen udefinert. Hvis en gruppe matcher flere ganger, vil bare den siste kampen være i arrayet.

Console.log(/bad(ly)?/.exec("bad")); // → ["dårlig", udefinert] console.log(/(\d)+/.exec("123")); // → ["123", "3"]

Grupper er nyttige for å hente deler av strenger. Hvis vi ikke bare vil sjekke om en streng har en dato, men trekke den ut og lage et objekt som representerer datoen, kan vi sette tallsekvensene i parentes og velge datoen fra resultatet av exec.

Men først, en liten digresjon der vi lærer den foretrukne måten å lagre dato og klokkeslett på i JavaScript.

Datotype

JavaScript har en standard objekttype for datoer – mer spesifikt, øyeblikk i tid. Det heter Date. Hvis du bare oppretter et datoobjekt ved hjelp av ny, får du gjeldende dato og klokkeslett.

Console.log(ny dato()); // → Søn 9. nov. 2014 00:07:57 GMT+0300 (CET)

Du kan også lage et objekt som inneholder en gitt tid

Console.log(ny dato(2015, 9, 21)); // → ons 21. okt. 2015 00:00:00 GMT+0300 (CET) console.log(ny dato(2009, 11, 9, 12, 59, 59, 999)); // → ons 09. desember 2009 12:59:59 GMT+0300 (CET)

JavaScript bruker en konvensjon der månedstall starter med en null og dagstall starter med en. Dette er dumt og latterlig. Vær forsiktig.

De fire siste argumentene (timer, minutter, sekunder og millisekunder) er valgfrie og er satt til null hvis de mangler.

Tidsstempler lagres som antall millisekunder som har gått siden begynnelsen av 1970. For tider før 1970 brukes negative tall (dette er på grunn av Unix-tidskonvensjonen som ble opprettet rundt den tiden). Datoobjektets getTime-metode returnerer dette tallet. Den er naturlig stor.
console.log(ny dato(2013, 11, 19).getTime()); // → 1387407600000 console.log(ny dato(1387407600000)); // → tor 19. desember 2013 00:00:00 GMT+0100 (CET)

Hvis du gir Dato-konstruktøren ett argument, behandles det som dette antallet millisekunder. Du kan få gjeldende millisekundverdi ved å opprette et Date-objekt og kalle opp getTime-metoden, eller ved å kalle Date.now-funksjonen.

Date-objektet har metodene getFullYear, getMonth, getDate, getHours, getMinutes og getSeconds for å hente komponentene. Det er også en getYear-metode som returnerer en ganske ubrukelig tosifret kode som 93 eller 14.

Ved å sette de relevante delene av malen i parentes, kan vi lage et datoobjekt direkte fra strengen.

Funksjon findDate(string) ( var dateTime = /(\d(1,2))-(\d(1,2))-(\d(4))/; var match = dateTime.exec(string); return new Date(Number(match), Number(match) - 1, Number(match)); ) console.log(findDate("30-1-2003")); // → Tor 30. jan 2003 00:00:00 GMT+0100 (CET)

Ord- og linjegrenser

Dessverre vil findDate like gjerne trekke ut den meningsløse datoen 00-1-3000 fra strengen "100-1-30000". Samsvaret kan skje hvor som helst i strengen, så i dette tilfellet vil det ganske enkelt starte med det andre tegnet og slutte med det nest siste tegnet.

Hvis vi må tvinge treffet til å ta hele strengen, bruker vi taggene ^ og $. ^ samsvarer med begynnelsen av linjen, og $ samsvarer med slutten. Derfor samsvarer /^\d+$/ en streng som inneholder bare ett eller flere sifre, /^!/ samsvarer med en streng som starter med et utropstegn, og /x^/ samsvarer ikke med noen streng (det kan ikke være en x).

Hvis vi derimot bare vil forsikre oss om at datoen starter og slutter på en ordgrense, bruker vi \b-merket. En ordgrense kan være begynnelsen eller slutten av en linje, eller et hvilket som helst sted i en linje der det er et alfanumerisk tegn \w på den ene siden og et ikke-alfanumerisk tegn på den andre.

Console.log(/cat/.test("sammenknytte")); // → true console.log(/\bcat\b/.test("sammenknytte")); // → usant

Merk at grenseetiketten ikke er et symbol. Det er ganske enkelt en begrensning, noe som betyr at et samsvar bare oppstår hvis en bestemt betingelse er oppfylt.

Maler med valg

La oss si at du må finne ut om teksten ikke bare inneholder et tall, men et tall etterfulgt av gris, ku eller kylling i entall eller flertall.

Det ville være mulig å skrive tre regulære uttrykk og sjekke dem ett etter ett, men det er en bedre måte. Symbol | betegner et valg mellom mønstrene til venstre og til høyre for den. Og vi kan si følgende:

Var animalCount = /\b\d+ (gris|ku|kylling)s?\b/; console.log(animalCount.test("15 griser")); // → true console.log(animalCount.test("15 grisekyllinger")); // → usant

Parenteser avgrenser delen av mønsteret som | brukes på, og mange slike operatorer kan plasseres etter hverandre for å indikere et valg mellom mer enn to alternativer.

Søkemotor

Regelmessige uttrykk kan betraktes som flytskjemaer. Følgende diagram beskriver et nylig husdyreksempel.

Et uttrykk samsvarer med en streng hvis det er mulig å finne en sti fra venstre side av diagrammet til høyre. Vi husker gjeldende posisjon i linjen, og hver gang vi går gjennom rektangelet, sjekker vi at delen av linjen rett etter posisjonen vår i den samsvarer med innholdet i rektangelet.

Dette betyr at det å se etter samsvar med vår vanlige karakter i strengen "de 3 griser" når du går gjennom flytskjemaet ser slik ut:

Ved posisjon 4 er det en ordgrense, og vi passerer det første rektangelet
- fra 4. posisjon finner vi tallet og går gjennom det andre rektangelet
- ved posisjon 5 lukkes den ene banen tilbake foran det andre rektangelet, og den andre går videre til rektangelet med et mellomrom. Vi har et mellomrom, ikke et tall, og vi velger den andre veien.
- nå er vi på posisjon 6, begynnelsen av "griser", og ved trippel forgrening av stiene. Det er ingen "ku" eller "kylling" i linjen, men det er "gris", så vi velger denne veien.
- ved posisjon 9 etter trippelgaffelen, omgår den ene banen "s" og går til grenserektangelet for det siste ordet, og den andre går gjennom "s". Vi har en "s" så vi drar dit.
- ved posisjon 10 er vi på slutten av linjen, og bare ordet grense kan matche. Enden av linjen regnes som grensen, og vi passerer gjennom det siste rektangelet. Og nå har vi funnet malen vår.

I utgangspunktet er måten regulære uttrykk fungerer på at algoritmen starter på begynnelsen av strengen og prøver å finne en match der. I vårt tilfelle er det en ordgrense, så den passerer det første rektangelet - men det er ikke noe tall der, så det snubler over det andre rektangelet. Så flytter den seg til det andre tegnet i strengen, og prøver å finne et samsvar der... Og så videre til det finner et samsvar eller kommer til slutten av strengen, i så fall blir det ikke funnet noe samsvar.

Tilbakeslag

Det regulære uttrykket /\b(+b|\d+|[\da-f]h)\b/ samsvarer med enten et binært tall etterfulgt av en b, et desimaltall uten suffiks, eller et heksadesimalt tall (tallene 0 til 9 eller symbolene fra a til h), etterfulgt av h. Relevant diagram:

Når du søker etter et samsvar, kan det hende at algoritmen tar den øverste banen (binært tall), selv om det ikke er et slikt tall i strengen. Hvis det for eksempel er en linje "103", er det klart at først etter å ha nådd tallet 3, vil algoritmen forstå at den er på feil vei. Generelt samsvarer linjen med den vanlige sekvensen, bare ikke i denne tråden.

Så ruller algoritmen tilbake. Ved en gaffel husker den gjeldende posisjon (i vårt tilfelle er dette begynnelsen på linjen, like etter ordet grense) slik at du kan gå tilbake og prøve en annen vei hvis den valgte ikke fungerer. For strengen "103", etter å ha møtt en treer, vil den gå tilbake og prøve å gå gjennom desimalbanen. Dette vil fungere, så en match vil bli funnet.

Algoritmen stopper så snart den finner en fullstendig match. Dette betyr at selv om flere alternativer kan være passende, brukes kun ett av dem (i den rekkefølgen de vises i den vanlige rekkefølgen).

Tilbakesporing skjer når du bruker repetisjonsoperatorer som + og *. Hvis du søker etter /^.*x/ i strengen "abcxe", vil regex-delen.* prøve å konsumere hele strengen. Algoritmen vil da innse at den også trenger "x". Siden det ikke er noen "x" etter slutten av strengen, vil algoritmen prøve å se etter samsvar ved å flytte ett tegn tilbake. Etter abcx er det heller ingen x, så ruller den tilbake igjen, denne gangen til understrengen abc. Og etter linjen finner den x og rapporterer en vellykket match, i posisjonene 0 til 4.

Du kan skrive en vanlig rutine som vil føre til flere tilbakeføringer. Dette problemet oppstår når mønsteret kan matche input på mange forskjellige måter. For eksempel, hvis vi gjør en feil når vi skriver det regulære uttrykket for binære tall, kan vi ved et uhell skrive noe som /(+)+b/.

Hvis algoritmen skulle se etter et slikt mønster i en lang streng med 0-er og 1-ere som ikke hadde en "b" på slutten, ville den først gå gjennom den indre løkken til den gikk tom for sifre. Da vil han legge merke til at det ikke er noen "b" på slutten, han vil rulle tilbake en posisjon, gå gjennom den ytre løkken, gi opp igjen, prøve å rulle tilbake til en annen posisjon langs den indre sløyfen... Og han vil fortsette å søke på denne måten ved å bruke begge løkkene. Det vil si at mengden arbeid med hvert tegn på linjen vil dobles. Selv for flere dusin karakterer vil det ta veldig lang tid å finne en match.

erstatte metoden

Strenger har en erstatningsmetode som kan erstatte en del av en streng med en annen streng.

Console.log("pappa".replace("p", "m")); // → kart

Det første argumentet kan også være et regulært uttrykk, i så fall erstattes den første forekomsten av det regulære uttrykket på linjen. Når alternativet "g" (globalt) legges til det regulære uttrykket, erstattes alle forekomster, ikke bare den første

Console.log("Borobudur".replace(//, "a")); // → Barobudur console.log("Borobudur".replace(//g, "a")); // → Barabadar

Det ville være fornuftig å sende alternativet "erstatt alle" gjennom et eget argument, eller gjennom en separat metode som replaceAll. Men dessverre overføres alternativet gjennom det vanlige systemet selv.

Den fulle kraften til regulære uttrykk avsløres når vi bruker lenker til grupper som finnes i en streng, spesifisert i det regulære uttrykket. For eksempel har vi en linje som inneholder personers navn, ett navn per linje, i formatet "Etternavn, Fornavn". Hvis vi trenger å bytte dem og fjerne kommaet for å få «Fornavn Etternavn», skriver vi følgende:

Console.log("Hopper, Grace\nMcCarthy, John\nRitchie, Dennis" .replace(/([\w ]+), ([\w ]+)/g, "$2 $1")); // → Grace Hopper // John McCarthy // Dennis Ritchie

$1 og $2 i erstatningslinjen refererer til grupper av tegn i parentes. $1 erstattes med teksten som samsvarer med den første gruppen, $2 med den andre gruppen, og så videre, opptil $9. Hele samsvaret er inneholdt i $&-variabelen.

Du kan også sende en funksjon som det andre argumentet. For hver erstatning vil det bli kalt en funksjon hvis argumenter vil være de funnet gruppene (og hele den matchende delen av linjen), og resultatet vil bli satt inn i en ny linje.

Enkelt eksempel:

Var s = "cia og fbi"; console.log(s.replace(/\b(fbi|cia)\b/g, function(str) (retur str.toUpperCase(); ))); // → CIA og FBI

Her er en mer interessant:

Var lager = "1 sitron, 2 kål og 101 egg"; function minusOne(match, amount, unit) ( amount = Number(amount) - 1; if (amount == 1) // bare én igjen, fjern "s" på slutten unit = unit.slice(0, unit. lengde - 1); else if (beløp == 0) beløp = "nei"; returbeløp + " " + enhet; ) console.log(stock.replace(/(\d+) (\w+)/g, minusOne) ); // → ingen sitron, 1 kål og 100 egg

Koden tar en streng, finner alle forekomster av tall etterfulgt av et ord, og returnerer en streng med hvert tall redusert med ett.

Gruppen (\d+) går inn i beløpsargumentet, og (\w+) går inn i enhetsargumentet. Funksjonen konverterer beløp til et tall - og dette fungerer alltid, fordi vårt mønster er \d+. Og gjør deretter endringer i ordet, i tilfelle det bare er 1 element igjen.

Grådighet

Det er enkelt å bruke erstatning for å skrive en funksjon som fjerner alle kommentarer fra JavaScript-kode. Her er første forsøk:

Funksjon stripComments(code) ( return code.replace(/\/\/.*|\/\*[^]*\*\//g, ""); ) console.log(stripComments("1 + /* 2 */3")); // → 1 + 3 console.log(stripComments("x = 10;// ti!")); // → x = 10; console.log(stripComments("1 /* a */+/* b */ 1")); // → 1 1

Delen før "eller"-operatoren samsvarer med to skråstreker etterfulgt av et hvilket som helst antall tegn unntatt nylinjer. Den delen som fjerner kommentarer med flere linjer er mer kompleks. Vi bruker [^], dvs. et hvilket som helst tegn som ikke er tomt som en måte å finne noen tegn. Vi kan ikke bruke et punktum fordi blokkkommentarer fortsetter på en ny linje, og linjeskifttegnet samsvarer ikke med punktum.

Men resultatet fra forrige eksempel er feil. Hvorfor?

[^]*-delen vil først prøve å fange så mange karakterer den kan. Hvis den neste delen av den vanlige sekvensen på grunn av dette ikke finner en match, vil den rulle tilbake ett tegn og prøve på nytt. I eksemplet prøver algoritmen å ta hele linjen, og ruller deretter tilbake. Etter å ha rullet tilbake 4 tegn, vil han finne */ i linjen - og dette er ikke det vi ønsket. Vi ønsket å ta bare én kommentar, og ikke gå til slutten av linjen og finne den siste kommentaren.

På grunn av dette sier vi at repetisjonsoperatorene (+, *, ?, og ()) er grådige, noe som betyr at de først griper så mye de kan og deretter går tilbake. Hvis du stiller et spørsmål etter en operator som dette (+?, *?, ??, ()?), vil de bli til ikke-grådige, og begynne å finne de minste mulige forekomstene.

Og det er det vi trenger. Ved å tvinge stjernen til å finne samsvar med minst mulig antall tegn på en linje, bruker vi bare én blokk med kommentarer, og ikke mer.

Funksjon stripComments(code) ( return code.replace(/\/\/.*|\/\*[^]*?\*\//g, ""); ) console.log(stripComments("1 /* a */+/* b */ 1")); // → 1 + 1

Mange feil oppstår ved bruk av grådige operatorer i stedet for ikke-grådige. Når du bruker repetisjonsoperatøren, må du alltid vurdere den ikke-grådige operatøren først.

Dynamisk oppretting av RegExp-objekter

I noen tilfeller er det nøyaktige mønsteret ukjent på tidspunktet koden skrives. Du må for eksempel se etter brukerens navn i teksten, og legge det ved understrek. Siden du først kjenner navnet etter å ha kjørt programmet, kan du ikke bruke skråstreknotasjon.

Men du kan konstruere strengen og bruke RegExp-konstruktøren. Her er et eksempel:

Var navn = "harry"; var text = "Og Harry har et arr i pannen."; var regexp = new RegExp("\\b(" + navn + ")\\b", "gi"); console.log(text.replace(regexp, "_$1_")); // → Og _Harry_ har et arr i pannen.

Når vi lager ordgrenser, må vi bruke doble skråstreker fordi vi skriver dem på en vanlig linje, og ikke i en vanlig rekkefølge med skråstreker fremover. Det andre argumentet til RegExp inneholder alternativer for regulære uttrykk - i vårt tilfelle "gi", dvs. global og skiller mellom store og små bokstaver.

Men hva om navnet er "dea+hlrd" (hvis brukeren vår er en kulhatzker)? Som et resultat vil vi få et meningsløst regulært uttrykk som ikke finner treff i strengen.

Vi kan legge til omvendte skråstreker før alle karakterer vi ikke liker. Vi kan ikke legge til omvendte skråstreker før bokstaver fordi \b eller \n er spesialtegn. Men du kan legge til skråstreker før alle ikke-alfanumeriske tegn uten problemer.

Var navn = "dea+hlrd"; var text = "Denne dea+hlrd irriterer alle."; var escaped = name.replace(/[^\w\s]/g, "\\$&"); var regexp = new RegExp("\\b(" + escaped + ")\\b", "gi"); console.log(text.replace(regexp, "_$1_")); // → Dette _dea+hlrd_ irriterte alle.

søkemetode

indexOf-metoden kan ikke brukes med regulære uttrykk. Men det er en søkemetode som bare forventer regulært uttrykk. Som indexOf, returnerer den indeksen for den første forekomsten, eller -1 hvis ingen forekommer.

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

Dessverre er det ingen måte å fortelle metoden om å se etter en kamp som starter med en spesifikk forskyvning (slik du kan gjøre med indexOf). Det ville være nyttig.

lastIndex-egenskapen

Exec-metoden gir heller ikke en praktisk måte å starte søket fra en gitt posisjon i strengen. Men det gir en upraktisk måte.

Et regulært uttrykk har egenskaper. En av dem er kilde, som inneholder en streng. En annen er lastIndex, som kontrollerer, under visse forhold, hvor neste søk etter forekomster vil begynne.

Disse betingelsene inkluderer at det globale alternativet g må være til stede, og at søket må gjøres ved hjelp av exec-metoden. En mer fornuftig løsning ville være å ganske enkelt tillate at et ekstra argument sendes til exec, men rimelighet er ikke en grunnleggende funksjon i JavaScript-regex-grensesnittet.

Var-mønster = /y/g; pattern.lastIndex = 3; var match = pattern.exec("xyzzy"); console.log(match.index); // → 4 console.log(pattern.lastIndex); // → 5

Hvis søket var vellykket, oppdaterer exec-kallet lastIndex-egenskapen til å peke på posisjonen etter den funnet forekomsten. Hvis det ikke var suksess, settes lastIndex til null - akkurat som lastIndex for det nyopprettede objektet.

Når du bruker en global regulær variabel og flere exec-kall, kan disse automatiske lastIndex-oppdateringene forårsake problemer. Din vanlige server kan begynne å søke fra posisjonen til venstre fra forrige samtale.

Var-siffer = /\d/g; console.log(digit.exec("her er det: 1")); // → ["1"] console.log(digit.exec("og nå: 1")); // → null

En annen interessant effekt av g-alternativet er at det endrer hvordan matchmetoden fungerer. Når den kalles med dette alternativet, i stedet for å returnere en matrise som ligner resultatet av exec, finner den alle forekomster av mønsteret i strengen og returnerer en matrise med de funnet delstrengene.

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

Så vær forsiktig med globale regulære variabler. De tilfellene der de er nødvendige - erstatt samtaler eller steder der du spesifikt bruker lastIndex - er sannsynligvis alle tilfellene de bør brukes i.

Forekomst sykluser

En typisk oppgave er å iterere gjennom alle forekomster av et mønster i en streng, slik at det kan få tilgang til matchobjektet i løkken ved hjelp av lastIndex og exec.

Var input = "En linje med 3 tall i... 42 og 88."; var nummer = /\b(\d+)\b/g; var match; while (match = number.exec(input)) console.log("Funnet", match, " på ", match.index); // → Funnet 3 x 14 // Funnet 42 x 33 // Funnet 88 x 40

Den utnytter det faktum at verdien av oppdraget er verdien som tildeles. Ved å bruke match = re.exec(input) som en betingelse i en while-løkke, søker vi i begynnelsen av hver iterasjon, lagrer resultatet i en variabel og avslutter loopen når alle treff er funnet.

Parsing INI-filer

For å avslutte kapitlet, la oss se på et problem ved å bruke regulære uttrykk. Tenk deg at vi skriver et program som samler informasjon om fiendene våre via Internett automatisk. (Vi vil ikke skrive hele programmet, bare den delen som leser innstillingsfilen. Beklager.) Filen ser slik ut:

Searchengine=http://www.google.com/search?q=$1 spitefulness=9.7 ; et semikolon er plassert før kommentarer; hver seksjon refererer til et annet fiende fullt navn=Larry Doe type=barnehage okse nettsted=http://www.geocities.com/CapeCanaveral/11451 fullname=Gargamel type=evil wizard outputdir=/home/marijn/enemies/gargamel

Det nøyaktige filformatet (som er ganske mye brukt, og vanligvis kalles INI) er som følger:

Tomme linjer og linjer som begynner med semikolon ignoreres
- linjer omsluttet av firkantede parenteser begynner en ny seksjon
- linjer som inneholder en alfanumerisk identifikator etterfulgt av = legg til en innstilling i denne delen

Alt annet er feil data.

Vår oppgave er å konvertere en slik streng til en rekke objekter, hver med en navneegenskap og en rekke innstillinger. Ett objekt er nødvendig for hver seksjon, og et annet er nødvendig for globale innstillinger på toppen av filen.

Siden filen må analyseres linje for linje, er det en god idé å starte med å dele opp filen i linjer. For å gjøre dette brukte vi string.split("\n") i kapittel 6. Noen operativsystemer bruker ikke ett \n-tegn for linjeskift, men to - \r\n. Siden split-metoden tar regulære uttrykk som et argument, kan vi dele linjer ved å bruke uttrykket /\r?\n/, slik at både enkelt \n og \r\n mellom linjer.

Funksjonen parseINI(streng) ( // La oss starte med et objekt som inneholder toppnivåinnstillinger var currentSection = (navn: null, felt: ); var categories = ; string.split(/\r?\n/).forEach(function (linje ) ( var match; if (/^\s*(;.*)?$/.test(line)) ( return; ) else if (match = line.match(/^\[(.*)\ ]$ /)) ( currentSection = (navn: match, felter: ); categories.push(currentSection); ) else if (match = line.match(/^(\w+)=(.*)$/)) ( currentSection. fields.push((navn: match, verdi: match)); ) else ( throw new Error("Linjen "" + linje + "" inneholder ugyldige data."); ) )); returkategorier; )

Koden går gjennom alle linjene, og oppdaterer det gjeldende seksjonsobjektet "current section". Først sjekker den om linjen kan ignoreres ved å bruke det regulære uttrykket /^\s*(;.*)?$/. Kan du forestille deg hvordan dette fungerer? Delen mellom parentesene stemmer med kommentarene, ikke sant? gjør det slik at det vanlige tegnet også vil matche linjer som kun består av mellomrom.

Hvis linjen ikke er en kommentar, sjekker koden for å se om den starter en ny seksjon. Hvis ja, opprettes et nytt objekt for gjeldende seksjon, som påfølgende innstillinger legges til.

Den siste meningsfulle muligheten er at strengen er en normal innstilling, i så fall legges den til det gjeldende objektet.

Hvis ingen av alternativene fungerer, gir funksjonen en feil.

Legg merke til hvordan hyppig bruk av ^ og $ sikrer at uttrykket samsvarer med hele strengen i stedet for bare en del av den. Hvis du ikke bruker dem, vil koden generelt fungere, men vil noen ganger gi merkelige resultater og feilen vil være vanskelig å spore opp.

If (match = string.match(...))-konstruksjonen ligner på trikset med å bruke tilordning som en betingelse i en while-løkke. Ofte vet du ikke at match-kallet vil lykkes, så du kan bare få tilgang til resultatobjektet i en if-blokk som sjekker etter det. For ikke å bryte den vakre kjeden av if-sjekker, tildeler vi søkeresultatet til en variabel og bruker umiddelbart denne tilordningen som en sjekk.

Internasjonale symboler

På grunn av den i utgangspunktet enkle implementeringen av språket, og den påfølgende fikseringen av en slik implementering "i granitt", er vanlige JavaScript-uttrykk dumme med tegn som ikke finnes på engelsk. For eksempel kan "bokstav"-tegnet, sett fra JavaScript-regulære uttrykk, være en av de 26 bokstavene i det engelske alfabetet, og av en eller annen grunn også et understrek. Bokstaver som é eller β, som tydeligvis er bokstaver, samsvarer ikke med \w (og vil samsvare med \W, som er en ikke-bokstav).

I en merkelig vri matcher historisk \s (mellomrom) alle tegn som anses som mellomrom i Unicode, inkludert ting som det ikke-brytende mellomrommet eller den mongolske vokalseparatoren.

Noen regex-implementeringer på andre språk har spesiell syntaks for å søke etter spesielle kategorier av Unicode-tegn, for eksempel "all caps", "all interpunctuation" eller "control characters". Det er planer om å legge til slike kategorier i JavaScript, men de vil sannsynligvis ikke bli implementert snart.

Bunnlinjen

Regelmessige er objekter som representerer søkemønstre i strenger. De bruker sin egen syntaks for å uttrykke disse mønstrene.

/abc/ Tegnsekvens
// Ethvert tegn fra listen
/[^abc]/ Ethvert tegn unntatt tegn fra listen
// Et hvilket som helst tegn fra intervallet
/x+/ En eller flere forekomster av mønsteret x
/x+?/ En eller flere forekomster, ikke-grådig
/x*/ Null eller flere forekomster
/x?/ Null eller én forekomst
/x(2,4)/ Fra to til fire forekomster
/(abc)/ Gruppe
/a|b|c/ Hvilket som helst av flere mønstre
/\d/ Hvilket som helst tall
/\w/ Ethvert alfanumerisk tegn ("bokstav")
/\s/ Ethvert mellomromstegn
/./ Alle tegn unntatt nylinjer
/\b/ Ordgrense
/^/ Start av linje
/$/ Slutt på linjen

Regex har en testmetode for å sjekke om mønsteret er i strengen. Det er en exec-metode som returnerer en matrise som inneholder alle gruppene som er funnet. Matrisen har en indeksegenskap, som inneholder nummeret til tegnet som samsvaret skjedde fra.

Strenger har en matchmetode for å matche mønstre, og en søkemetode som bare returnerer startposisjonen til forekomsten. Erstatningsmetoden kan erstatte forekomster av et mønster med en annen streng. I tillegg kan du sende en funksjon for å erstatte som vil bygge en erstatningslinje basert på malen og funnet grupper.

Vanlige tegn har innstillinger som er skrevet etter den avsluttende skråstreken. Alternativet i gjør det regulære uttrykket ufølsomt for store og små bokstaver, og alternativet g gjør det globalt, noe som blant annet gjør at erstatningsmetoden erstatter alle forekomster som er funnet, ikke bare den første.

RegExp-konstruktøren kan brukes til å lage regulære uttrykk fra strenger.

Regulatorer er et skarpt instrument med et ubehagelig håndtak. De forenkler noen oppgaver i stor grad, og kan bli uhåndterlige når man løser andre, komplekse problemer. En del av å lære å bruke regexes er å kunne motstå fristelsen til å fylle dem med en oppgave de ikke er ment for.

Øvelser

Når du løser problemer, vil du uunngåelig møte uforståelige tilfeller, og du kan noen ganger fortvile når du ser den uforutsigbare oppførselen til noen regulære uttrykk. Noen ganger hjelper det å studere oppførselen til en vanlig motor gjennom en nettjeneste som debuggex.com, hvor du kan se visualiseringen og sammenligne den med ønsket effekt.

Vanlig golf

"Golf" i kode er et spill hvor du må uttrykke et gitt program med et minimum antall tegn. Vanlig golf er en praktisk øvelse i å skrive minst mulig gjengangere for å finne et gitt mønster, og bare det.

For hver av underlinjene skriver du et regulært uttrykk for å sjekke plasseringen i linjen. Den vanlige motoren skal bare finne disse spesifiserte understrengene. Ikke bekymre deg for ordgrenser med mindre det er spesifikt nevnt. Når du har et fungerende vanlig mønster, prøv å redusere det.

Bil og katt
- pop og prop
- ilder, ferge og ferrari
- Ethvert ord som slutter på ious
- Et mellomrom etterfulgt av et punktum, komma, kolon eller semikolon.
- Et ord lengre enn seks bokstaver
- Ord uten bokstaver e

// Skriv inn dine vanlige uttrykk verify(/.../, ["min bil", "bad cats"], ["camper", "high art"]); verify(/.../, ["popkultur", "gal rekvisitter"], ["plopp"]); verify(/.../, ["ilder", "ferge", "ferrari"], ["ferrum", "overføring A"]); verify(/.../, ["hvor deilig", "romslig rom"], ["ødeleggende", "bevissthet"]); verify(/.../, ["dårlig tegnsetting ."], ["escape the dot"]); verify(/.../, ["hottenottententen"], ["no", "hottentottententen"]); verify(/.../, ["rød nebbdyr", "wobbling nest"], ["jordseng", "lærende ape"]); function verify(regexp, yes, no) ( // Ignorer uferdige øvelser if (regexp.source == "...") return; yes.forEach(function(s) (if (!regexp.test(s)) console .log("Ikke funnet "" + s + """); )); no.forEach(funksjon(er) (if (regexp.test(s)) console.log("Uventet forekomst av "" + s + " ""); )); )

Sitater i tekst

La oss si at du skrev en historie og brukte enkeltsitater for å indikere dialog. Nå vil du erstatte dialoganførselstegnene med doble anførselstegn, og la de enkle anførselstegnene stå i forkortelser for ord som ikke er det.

Kom opp med et mønster som skiller mellom disse to bruken av anførselstegn, og skriv en oppfordring til erstatningsmetoden som gjør erstatningen.

Tall igjen

Sekvenser av tall kan bli funnet med et enkelt regulært uttrykk /\d+/.

Skriv et uttrykk som bare finner tall skrevet i JavaScript-stil. Den må støtte et mulig minus eller pluss foran tallet, et desimaltegn og vitenskapelig notasjon 5e-3 eller 1E10 - igjen med et mulig pluss eller minus. Vær også oppmerksom på at det ikke nødvendigvis er tall før eller etter prikken, men tallet kan ikke bestå av en enkelt prikk. Det vil si at .5 eller 5. er gyldige tall, men en prikk i seg selv er det ikke.

// Skriv inn den vanlige sekvensen her. var nummer = /^...$/; // Tester: ["1", "-1", "+15", "1.55", ".5", "5.", "1.3e2", "1E-4", "1e+12"] .forEach(function(s) ( if (!number.test(s)) console.log("Fant ikke "" + s + """); )); ["1a", "+-1", "1.2.3", "1+1", "1e4.5", ".5.", "1f5", "."].forHver(funksjon(er) ( if (number.test(s)) console.log("Feilaktig akseptert "" + s + """); ));

Juksearket er en generell guide til vanlige uttrykksmønstre uten å ta hensyn til spesifikasjonene til noe språk. Den presenteres i form av et bord som passer på ett trykt ark i A4-størrelse. Laget under en Creative Commons-lisens basert på et jukseark skrevet av Dave Child ().

Husk at forskjellige programmeringsspråk støtter regulære uttrykk i ulik grad, så du kan støte på en situasjon der noen av funksjonene som vises ikke fungerer. For de som bare skal bli kjent med vanlige uttrykk, tilbys denne oversettelsen av forfatterens kommentarer til juksearket. Den vil introdusere deg til noen av teknikkene som brukes til å bygge regulære uttrykksmønstre.

Ankre i regulære uttrykk indikerer begynnelsen eller slutten av noe. For eksempel linjer eller ord. De er representert med visse symboler. For eksempel, et mønster som samsvarer med en streng som starter med et tall, vil se slik ut:

Her betegner tegnet ^ begynnelsen av linjen. Uten det ville mønsteret matche enhver streng som inneholder et siffer.

Tegnklasser i regulære uttrykk samsvarer med et bestemt sett med tegn samtidig. For eksempel, \d samsvarer med et hvilket som helst tall fra 0 til og med 9, \w samsvarer med bokstaver og tall, og \W samsvarer med alle andre tegn enn bokstaver og tall. Mønsteret som identifiserer bokstaver, tall og mellomrom ser slik ut:

POSIX

POSIX er et relativt nytt tilskudd til regulære uttrykksfamilien. Ideen, som med karakterklasser, er å bruke snarveier som representerer en gruppe karakterer.

Nesten alle har problemer med å forstå bekreftelser i begynnelsen, men etter hvert som du blir mer kjent med dem, vil du finne deg selv å bruke dem ganske ofte. Påstander gir en måte å si: "Jeg vil finne hvert ord i dette dokumentet som inkluderer bokstaven "q" og ikke etterfølges av "werty."

[^\s]*q(?!werty)[^\s]*

Koden ovenfor starter med å søke etter andre tegn enn mellomrom ([^\s]*) etterfulgt av q . Parseren kommer så til en fremtidsrettet påstand. Dette gjør automatisk det foregående elementet (tegn, gruppe eller tegnklasse) betinget – det vil matche mønsteret bare hvis utsagnet er sant. I vårt tilfelle er utsagnet negativt (?!), det vil si at det vil være sant dersom det som søkes i den ikke blir funnet.

Så parseren sjekker de neste tegnene mot det foreslåtte mønsteret (werty). Hvis de blir funnet, er setningen usann, noe som betyr at tegnet q vil bli "ignorert", det vil si at det ikke samsvarer med mønsteret. Hvis werty ikke er funnet, er påstanden sann, og alt er i orden med q. Deretter fortsetter søket etter andre tegn enn mellomrom ([^\s]*).

Denne gruppen inneholder eksempelmaler. Med deres hjelp kan du se hvordan regulære uttrykk kan brukes i daglig praksis. Vær imidlertid oppmerksom på at de ikke nødvendigvis vil fungere i alle programmeringsspråk, da hver har sine egne unike funksjoner og varierende nivåer av støtte for regulære uttrykk.

Kvantifiserere lar deg definere en del av et mønster som må gjentas flere ganger på rad. Hvis du for eksempel vil finne ut om et dokument inneholder en streng med 10 til 20 (inklusive) bokstaver "a", kan du bruke dette mønsteret:

A(10,20)

Som standard er kvantifiserere "grådige". Derfor vil kvantifikatoren +, som betyr "en eller flere ganger," tilsvare den maksimalt mulige verdien. Noen ganger forårsaker dette problemer, i så fall kan du fortelle kvantifisereren å slutte å være grådig (bli "lat") ved å bruke en spesiell modifikator. Se på denne koden:

".*"

Dette mønsteret samsvarer med tekst i doble anførselstegn. Kildelinjen din kan imidlertid være noe slikt:

Hei Verden

Malen ovenfor vil finne følgende understreng på denne linjen:

"helloworld.htm" title="Hello World" !}

Han viste seg å være for grådig, og tok tak i den største teksten han kunne.

".*?"

Dette mønsteret samsvarer også med alle tegn i doble anførselstegn. Men den late versjonen (legg merke til modifikatoren?) ser etter den minste mulige forekomsten, og vil derfor finne hver delstreng med doble anførselstegn:

"helloworld.htm" "Hello World"

Vanlige uttrykk bruker visse tegn for å representere ulike deler av et mønster. Det oppstår imidlertid et problem hvis du trenger å finne en av disse tegnene i en streng, akkurat som et vanlig tegn. En prikk, for eksempel, i et regulært uttrykk betyr "hvilket som helst annet tegn enn et linjeskift." Hvis du trenger å finne et punkt i en streng, kan du ikke bare bruke " . » som en mal - dette vil føre til å finne nesten hva som helst. Så du må fortelle parseren at denne prikken skal betraktes som en vanlig prikk og ikke "hvilken som helst karakter". Dette gjøres ved hjelp av et rømningsskilt.

Et escape-tegn foran et tegn, for eksempel en prikk, får parseren til å ignorere funksjonen og behandle den som et normalt tegn. Det er flere tegn som krever slik escape i de fleste maler og språk. Du finner dem i nedre høyre hjørne av juksearket ("Metasymboler").

Mønsteret for å finne et punkt er:

\.

Andre spesialtegn i regulære uttrykk samsvarer med uvanlige elementer i tekst. Linjeskift og tabulatorer, for eksempel, kan skrives på tastaturet, men vil sannsynligvis forvirre programmeringsspråk. Escape-tegnet brukes her for å fortelle parseren å behandle det neste tegnet som et spesialtegn i stedet for en vanlig bokstav eller tall.

Strengerstatning er beskrevet i detalj i neste avsnitt, "Grupper og områder", men eksistensen av "passive" grupper bør nevnes her. Dette er grupper som ignoreres under substitusjon, noe som er veldig nyttig hvis du ønsker å bruke en "eller"-betingelse i et mønster, men ikke ønsker at gruppen skal ta del i substitusjonen.

Grupper og områder er veldig, veldig nyttige. Det er nok lettere å starte med områder. De lar deg spesifisere et sett med passende tegn. For å sjekke om en streng for eksempel inneholder heksadesimale sifre (0 til 9 og A til F), bruker du følgende område:

For å sjekke det motsatte, bruk et negativt område, som i vårt tilfelle passer til alle tegn bortsett fra tall fra 0 til 9 og bokstaver fra A til F:

[^A-Fa-f0-9]

Grupper brukes oftest når en "eller"-tilstand er nødvendig i et mønster; når du trenger å referere til en del av en mal fra en annen del av den; og også når du erstatter strenger.

Å bruke "eller" er veldig enkelt: følgende mønster ser etter "ab" eller "bc":

Hvis det i et regulært uttrykk er nødvendig å referere til en av de tidligere gruppene, bør du bruke \n , hvor i stedet for n erstatter nummeret til ønsket gruppe. Du vil kanskje ha et mønster som samsvarer med bokstavene "aaa" eller "bbb" etterfulgt av et tall og deretter de samme tre bokstavene. Dette mønsteret implementeres ved hjelp av grupper:

(aaa|bbb)+\1

Den første delen av mønsteret ser etter "aaa" eller "bbb", og kombinerer bokstavene funnet i en gruppe. Dette etterfølges av et søk etter ett eller flere sifre (+), og til slutt \1. Den siste delen av mønsteret refererer til den første gruppen og ser etter det samme. Den ser etter en match med teksten som allerede er funnet av den første delen av mønsteret, ikke en match til den. Så "aaa123bbb" vil ikke tilfredsstille mønsteret ovenfor siden \1 vil se etter "aaa" etter tallet.

Et av de mest nyttige verktøyene i regulære uttrykk er strengerstatning. Når du erstatter tekst, kan du referere til gruppen som ble funnet ved å bruke $n . La oss si at du vil markere alle ordene "ønske" i tekst med fet skrift. For å gjøre dette bør du bruke en erstatningsfunksjon for regulære uttrykk, som kan se slik ut:

Erstatt (mønster, erstatning, emne)

Den første parameteren vil være noe sånt som dette (du kan trenge noen ekstra tegn for denne spesielle funksjonen):

([^A-Za-z0-9])(ønske)([^A-Za-z0-9])

Den vil finne alle forekomster av ordet "ønske" sammen med de forrige og neste tegnene, så lenge de ikke er bokstaver eller tall. Da kan erstatningen din være slik:

$1$2$3

Det vil erstatte hele strengen som ble funnet ved hjelp av mønsteret. Vi begynner å erstatte med det første tegnet som ble funnet (det er ikke en bokstav eller et tall), og merker det $1 . Uten dette ville vi ganske enkelt fjernet dette tegnet fra teksten. Det samme gjelder slutten av byttet ($3). I midten har vi lagt til en HTML-tag for fet skrift (selvfølgelig kan du bruke CSS eller ), og tildeler dem den andre gruppen funnet ved hjelp av malen ($2).

Malmodifikatorer brukes på flere språk, spesielt Perl. De lar deg endre hvordan parseren fungerer. For eksempel fører i-modifikatoren til at parseren ignorerer tilfeller.

Vanlige uttrykk i Perl er omgitt av samme karakter i begynnelsen og på slutten. Dette kan være et hvilket som helst tegn (oftest brukes "/"), og det ser slik ut:

/mønster/

Modifikatorer legges til på slutten av denne linjen, slik:

/mønster/i

Til slutt inneholder den siste delen av tabellen metategn. Dette er tegn som har spesiell betydning i regulære uttrykk. Så hvis du vil bruke en av dem som en vanlig karakter, må den unnslippes. For å sjekke om det er en parentes i teksten, bruk følgende mønster:

Virkelig, takk. spesielt for avklaringen. Du er velkommen :) tusen takk. Tusen takk! Takk Cool serie... forresten, jeg oversetter denne serien fra engelsk (og gjør den i HTML-format), du kan se den på nettstedet mitt: sitemaker.x10.bz. Det er også et jukseark på HTML, som ikke er her. Takk skal du ha. Hva med å fjerne de første 10 tegnene av noe slag, og så blir det litt tekst med symboler, og så fra et bestemt symbol må du fjerne alt til slutten. !? 2 lails: Regelmessige uttrykk er ikke nødvendig her. Substr() og strpos() vil hjelpe deg hvis vi snakker om PHP, eller deres analoger på andre språk. Det var interessant å lese om utsagnene, jeg begynner så smått å forstå. Det blir tydeligere på denne måten: http://pcreonline.com/OazZNu/ Hei. Fortell meg hvorfor "bakoverskuende utsagn" ikke fungerer for meg i FireFox? Mozillas RegExp-hjelp har dem ikke i det hele tatt, er det virkelig umulig i Fox? =((( God morgen, bakoverskuende utsagn støttes ikke av JavaScript, så de vil etter all sannsynlighet ikke fungere i andre nettlesere heller. Denne lenken har mer detaljert informasjon om begrensningene for regulære uttrykk i JavaScript-språket. Godt gjort! Gi et rop! Takk! Kort og tydelig! Hmm. Pasiba) Takk! takk, det var veldig nyttig tusen takk! Takk for artikkelen! Fortell meg, hva om du trenger å begrense passordoppføringen til tall og skriv ikke mer enn 5 bokstaver Hei, juksearket er bra for alle, men det ville være mulig å gjøre sebraen lysere, for når du skriver ut svarte bokstaver på mørk bakgrunn er det ikke så bra Takk. Et raskt spørsmål, du må finne verdiene mellom start= og &, men samtidig ekskludere disse områdegrensene fra utdataene. Slik finner du området: start=.(1,)&
Men det er fortsatt ikke nok kunnskap om hvordan man kan eliminere grenser. Jeg vil være takknemlig for din hjelp. Fortell meg hvordan jeg setter et regulært uttrykk for å sjekke (det kan være samsvar eller ikke)? Hvordan skrive et regulært uttrykk som starter med likhetstegnet, finner hvilken som helst tekst inni og stopper ved &-tegnet riktig
Disse tegnene er ikke inkludert i søket; den nødvendige delen av strengen begynner og slutter med dem...

Jeg skriver på flere måter, men som et resultat blir enten all teksten igjen, men = og &-tegnene forsvinner
Eller forblir & på slutten av linjen...
Jeg leste om dollaren, den fjerner ikke tegnet på slutten av linjen

lite eksempel

var reg = /[^=]*[^&]/g
str.match(reg);

Logisk sett starter vi med likhetstegnet og ser etter hvilken som helst tekst /[^=]*
så stopper vi ved skiltet & [^&] uten å inkludere det i søket og gjentar søket lenger til vi går helt rundt /g

Fungerer ikke... Returnerer hele strengen

God kveld, fortell meg hvordan jeg finner et tall som er mindre enn 20? Takk folkens Takk for artikkelen! Fortell meg, hva om du trenger å begrense passordoppføringen til tall og ikke mer enn 5 bokstaver?

Dima @ 24. april 2015
Svar:((?=.*\d)(?=.*)(?=.*).(8,15))--- på slutten, i stedet for 8, setter du bare 5

Hei alle sammen, jeg har akkurat begynt...
Kan du fortelle meg hva det betyr:
/^\w\w/a
Jeg ville vært veldig takknemlig) Hei, fortell meg hvordan jeg skal liste opp alle tallene i dette uttrykket atskilt med et mellomrom 9*2 guddommelig jukseark! Løste alle spørsmålene :-) (M1)
(M2)
(M3)
(M4)
(M5)

Fortell meg hvordan jeg skriver et uttrykk for å finne hvor det forekommer i teksten

Takk skal du ha!