Sužinokite reguliarias išraiškas naudodami šį nemokamą kursą

„Kai kurie žmonės, susidūrę su problema, mano:„ Žinau, naudosiu įprastus posakius “. Dabar jie turi dvi problemas “. -Jamie Zawinski

Kai kuriems žmonėms reguliarių posakių vartojimas gali būti problema. Bet tai neturi būti jūsų problema. Šis straipsnis yra išsamus reguliariųjų posakių kursas.

1. Įvadas

Reguliarūs reiškiniai arba tiesiog „RegEx“ naudojami beveik visose programavimo kalbose, kad apibrėžtų paieškos modelį, kurį galima naudoti ieškant dalykų eilutėje.

Sukūriau nemokamą pilną vaizdo įrašų kursą svetainėje Scrimba.com, kuriame mokysiu reguliarių posakių pagrindų.

Šiame straipsnyje kursas pateikiamas rašytine forma. Bet jei norėtumėte žiūrėti vaizdo įrašą su interaktyviomis pamokomis, galite tai patikrinti „Scrimba“. Šio straipsnio skyriai atitinka „Scimba“ kurso skyrius.

Šis kursas tęsiamas kartu su „RegEx“ programa freeCodeCamp.org. Galite patikrinti, ar nėra kodavimo iššūkių, ir gauti sertifikatą.

Šiose pamokose daugiausia dėmesio skiriama „RegEx“ naudojimui „JavaScript“, tačiau principai galioja daugelyje kitų programavimo kalbų, kurias galite pasirinkti naudoti. Jei dar nežinote pagrindinės „JavaScript“, tai gali būti naudinga, jei pirmiausia ją šiek tiek padengsite. Taip pat turiu pagrindinį „JavaScript“ kursą, kurį galite pasiekti „Scrimba“ ir „freeCodeCamp.org“ „YouTube“ kanale.

Taigi pradėkime! Greitai sutaupysite dieną. ?

2. Naudojant bandymo metodą

Norėdami suderinti eilučių dalis naudodami „RegEx“, turime sukurti modelius, kurie padėtų jums atlikti tą atitikimą. Mes galime nurodyti, kad kažkas yra „RegEx“ modelis, įdėdami modelį tarp pasvirųjų brūkšnių /, panašiai /pattern-we-want-to-match/.

Pažvelkime į pavyzdį:

// We want to check the following sentencelet sentence = "The dog chased the cat."
// and this is the pattern we want to match.let regex = /the/

Atkreipkite dėmesį, kaip mes naudojame /the/nurodydami, kad ieškome „the“ savyje sentence.

Mes galime naudoti „RegEx“ test()metodą norėdami pasakyti, ar šablone yra eilutė, ar ne.

// String we want to testlet myString = "Hello, World!";
// Pattern we want to findlet myRegex = /Hello/;
// result is now truelet result = myRegex.test(myString);

3. Derinkite pažodines stygas

Dabar rasime Waldo.

let waldoIsHiding = "Somewhere Waldo is hiding in this text.";let waldoRegex = /Waldo/;
// test() returns true, so result is now also truelet result = waldoRegex.test(waldoIsHiding);

Atkreipkite dėmesį, kad šiame pavyzdyje skiriamos didžiosios ir mažosios waldoRegexraidės, taigi, jei /waldo/rašytume mažosiomis raidėmis „w“, mūsų reikšmė resultbūtų klaidinga.

4. Suderinkite pažodinę stygą su skirtingomis galimybėmis

„RegEx“ taip pat turi ORoperatorių, kuris yra |simbolis.

let petString = "James has a pet cat.";
// We can now try to find if either of the words are in the sentencelet petRegex = /dog|cat|bird|fish/;
let result = petRegex.test(petString);

5. Nepaisykite didžiųjų ir mažųjų raidžių

Iki šiol mes žiūrėjome į modelius, kai raidžių atvejis buvo svarbus. Kaip mes galime padaryti, kad mūsų RegEx modeliai būtų neskiriami didžiosioms ir mažosioms raidėms?

Norėdami nepaisyti didžiųjų ir mažųjų raidžių, galime tai padaryti pridėdami ižymę modelio pabaigoje, panašiai /some-pattern/i.

let myString = "freeCodeCamp";
// We ignore case by using 'i' flaglet fccRegex = /freecodecamp/i;
// result is truelet result = fccRegex.test(myString);

6. Ištraukite degtukus

Kai norime išgauti suderintą vertę, galime naudoti match()metodą.

let extractStr = "Extract the word 'coding' from this string.";
let codingRegex = /coding/;
let result = extractStr.match(codingRegex);
console.log(result);
// Terminal will show: // > ["coding"]

7. Raskite daugiau nei pirmosios rungtynės

Dabar, kai žinome, kaip išgauti vieną vertę, taip pat galima išskleisti kelias reikšmes naudojant gvėliavą

let testStr = "Repeat, Repeat, Repeat";
let ourRegex = /Repeat/g;
testStr.match(ourRegex); // returns ["Repeat", "Repeat", "Repeat"]

Mes taip pat galime sujungti gvėliavą su ivėliava, kad išgautume kelis atitikmenis ir nepaisytume korpuso.

let twinkleStar = "Twinkle, twinkle, little star";
let starRegex = /twinkle/ig;// writing /twinkle/gi would have the same result.
let result = twinkleStar.match(starRegex);
console.log(result);
// Terminal will show: // > ["Twinkle", "twinkle"]

8. Viską suderinkite su pakaitos periodu

„RegEx“ .yra pakaitos simbolis, kuris atitiktų bet ką.

let humStr = "I'll hum a song";
let hugStr = "Bear hug";
// Looks for anything with 3 characters beginning with 'hu'let huRegex = /hu./;
humStr.match(huRegex); // Returns ["hum"]
hugStr.match(huRegex); // Returns ["hug"]

9. Suderinkite vieną simbolį su keliomis galimybėmis

Bet kurio simbolio atitikimas yra gražus, bet ką daryti, jei norime apriboti atitikimą iš anksto nustatytu simbolių rinkiniu? Tai galime padaryti naudodami „ []RegEx“.

Jei turime /b[aiu]g/, tai reiškia, kad galime suderinti „krepšį“, „didelį“ ir „klaidą“.

Jei norime iš sakinio išskirti visus balsius, tai galime tai padaryti naudodami „RegEx“.

let quoteSample = "Beware of bugs in the above code; I have only proved it correct, not tried it.";
let vowelRegex = /[aeiou]/ig;
let result = quoteSample.match(vowelRegex);

10. Rungtynių abėcėlės raidės

Bet ką daryti, jei norime suderinti raidžių diapazoną? Aišku, padarykime tai.

let quoteSample = "The quick brown fox jumps over the lazy dog.";
// We can match all the letters from 'a' to 'z', ignoring casing. let alphabetRegex = /[a-z]/ig;
let result = quoteSample.match(alphabetRegex);

11. Rungtynių skaičiai ir abėcėlės raidės

Laiškai yra geri, bet kas, jei mes taip pat norime skaičių?

let quoteSample = "Blueberry 3.141592653s are delicious.";
// match numbers between 2 and 6 (both inclusive), // and letters between 'h' and 's'. let myRegex = /[2-6h-s]/ig;
let result = quoteSample.match(myRegex);

12. Pavienių simbolių atitikimas nenurodytas

Kartais lengviau nurodyti simbolius, kurių nenorite žiūrėti. Tai vadinama „neigiamais simboliais“, o „RegEx“ galite tai padaryti naudodami ^.

let quoteSample = "3 blind mice.";
// Match everything that is not a number or a vowel. let myRegex = /[^0-9aeiou]/ig;
let result = quoteSample.match(myRegex);// Returns [" ", "b", "l", "n", "d", " ", "m", "c", "."]

13. Derinkite veikėjus, kurie pasitaiko vieną ar daugiau kartų

Jei norite suderinti simbolius, atsirandančius vieną ar daugiau kartų, galite naudoti +.

let difficultSpelling = "Mississippi";
let myRegex = /s+/g;
let result = difficultSpelling.match(myRegex);// Returns ["ss", "ss"]

14. Derinkite personažus, kurie būna nulio ar daugiau kartų

Taip pat yra „ *RegEx“ kiekybinis koeficientas. Šis atitinka net 0 simbolio atvejų. Kodėl tai gali būti naudinga? Dažniausiai tai derinama su kitais personažais. Pažvelkime į pavyzdį.

let soccerWord = "gooooooooal!";
let gPhrase = "gut feeling";
let oPhrase = "over the moon";
// We are trying to match 'g', 'go', 'goo', 'gooo' and so on. let goRegex = /go*/;
soccerWord.match(goRegex); // Returns ["goooooooo"]
gPhrase.match(goRegex); // Returns ["g"]
oPhrase.match(goRegex); // Returns null

15. Raskite personažus su „Lazy Matching“

Kartais jūsų modelių atitikmenys gali sukelti daugiau nei vieną rezultatą. Pavyzdžiui, tarkime, kad ieškau šablono žodyje, titanico mano suderintos vertės turi prasidėti „t“ ir baigtis „i“. Mano galimi rezultatai yra „titani“ ir „ti“.

Štai kodėl „RegEx“ turi „Greedy Match“ ir „Lazy Match“ sąvokas.

Gobšus rungtynės randa savo ilgiausią įmanomą rungtynes iš eilutės, kad tinka RegEx modelis, tai yra numatytoji RegEx rungtynės:

let string = "titanic";
let regex = /t[a-z]*i/;
string.match(regex);// Returns ["titani"]

Tingus rungtynės nustato , kad trumpiausią įmanomą rungtynes iš eilutės, kad tinka RegEx modelis ir jį naudoti, mes turime naudoti ?:

let string = "titanic";
let regex = /t[a-z]*?i/;
string.match(regex);// Returns ["ti"]

16. Medžioklėje raskite vieną ar daugiau nusikaltėlių

Dabar pažvelkime į „RegEx“ iššūkį. Turime surasti visus nusikaltėlius („C“) iš minios. Mes žinome, kad jie visada būna kartu ir jums reikia parašyti „RegEx“, kuris juos surastų.

let crowd = 'P1P2P3P4P5P6CCCP7P8P9';
let reCriminals = /./; // Change this line
let matchedCriminals = crowd.match(reCriminals);

Šioje „Scrimba“ grupėje galite rasti mane einantį per sprendimą.

17. Rungtynių pradžios styginių raštai

„RegEx“ taip pat leidžia suderinti šablonus, kurie yra tik eilutės pradžioje. Mes jau kalbėjome apie ^neigiamo rinkinio sukūrimą. Tuo pačiu simboliu galime rasti atitikmenį tik eilutės pradžioje.

let calAndRicky = "Cal and Ricky both like racing.";
// Match 'Cal' only if it's at the beginning of a string. let calRegex = /^Cal/;
let result = calRegex.test(calAndRicky); // Returns true
let rickyAndCal = "Ricky and Cal both like racing.";
let result = calRegex.test(rickyAndCal); // Returns false

18. Rungtynių pabaigos eilutės modeliai

O kaip derinti modelį eilutės gale? Mes galime tai naudoti $.

let caboose = "The last car on a train is the caboose";
// Match 'caboose' if it's at the end of a string.let lastRegex = /caboose$/;
let result = lastRegex.test(caboose); // Returns true

19. Sutapkite visus raides ir skaičius

Anksčiau 10 ir 11 dalyse aš jums parodžiau, kaip galime suderinti raidžių ir skaičių diapazonus. Jei aš paprašyčiau jūsų parašyti „RegEx“, kuris atitiktų visas raides ir skaičius, ir nepaisyti jų atvejų, tikriausiai būtumėte parašę kažką panašaus /[a-z0-9]/giir būtent taip. Bet tai šiek tiek per ilgai.

„RegEx“ turi tai, kas vadinama „Shorthand Character Classes“ , o tai iš esmės yra bendros „RegEx“ išraiškos trumpinys. Norėdami suderinti visas raides ir skaičius, kuriuos galime naudoti, \wtaip pat gausime pabraukimą, _suderintą kaip premiją.

let quoteSample = "The five boxing wizards jump quickly.";
// Same as /[a-z0-9_]/gi to match a-z (ignore case), 0-9 and _let alphabetRegexV2 = /\w/g;
// The length of all the characters in a string// excluding spaces and the period. let result = quoteSample.match(alphabetRegexV2).length;
// Returns 31

20. Derinkite viską, išskyrus raides ir skaičius

Jei norime elgtis priešingai ir suderinti viską, kas nėra raidė ar skaičius (taip pat neįtraukti pabraukimo _), galime naudoti\W

let quoteSample = "The five boxing wizards jump quickly.";
// Match spaces and the periodlet nonAlphabetRegex = /\W/g;
let result = quoteSample.match(nonAlphabetRegex).length;
// Returns 6

21. Suderinkite visus skaičius

Gerai, o ką daryti, jei norite tik skaičių? Ar tam yra trumpų veikėjų klasė? Aišku, taip \d.

let numString = "Your sandwich will be $5.00";
// Match all the numberslet numRegex = /\d/g;
let result = numString.match(numRegex).length; // Returns 3

22. Derinkite visus ne skaičius

Ar norėtumėte priešingai ir sutapatintumėte visus ne skaičius? Naudokite\D

let numString = "Your sandwich will be $5.00";
// Match everything that is not a numberlet noNumRegex = /\D/g;
let result = numString.match(noNumRegex).length; // Returns 24

23. Apriboti galimus vartotojo vardus

Kol kas viskas gerai! Puikiai padaryta, kad pavyko taip toli. „RegEx“ gali būti keblus, nes tai nėra lengviausiai skaitomas būdas koduoti. Pažvelkime į labai realų pavyzdį ir sukurkime vartotojo vardo tikrintuvą. Tokiu atveju turite 3 reikalavimus:

  • Jei yra skaičių, jie turi būti pabaigoje.
  • Raidės gali būti mažosios ir didžiosios.
  • Bent dviejų simbolių ilgis. Dviejų raidžių pavadinimuose negali būti skaičių.

Pabandykite tai išspręsti patys ir, jei jums sunku ar tiesiog norite patikrinti atsakymą, patikrinkite mano sprendimą.

24. Rungtynių tarpas

Ar galime prilygti visiems tarpams? Žinoma, mes taip pat galime naudoti trumpinį ir viskas\s

let sample = "Whitespace is important in separating words";
// Match all the whitespaceslet countWhiteSpace = /\s/g;
let result = sample.match(countWhiteSpace);
// Returns [" ", " ", " ", " ", " "]

25. Suderinkite simbolius, kuriuose nėra tarpų

Ar galite atspėti, kaip suderinti visus ne tarpo simbolius? Puikiai padaryta, tai \S!

let sample = "Whitespace is important in separating words";
// Match all non-whitespace characterslet countWhiteSpace = /\S/g;
let result = sample.match(countWhiteSpace);

26. Nurodykite viršutinį ir apatinį rungtynių skaičių

Apatinį ir viršutinį raštų atitikmenų skaičių galite nurodyti naudodami parinktį „Kiekio specifikatoriai“. Jie gali būti naudojami {}, pavyzdžiui {3,6}, su sintakse, kur 3yra apatinė ir 6viršutinė ribos, kurios turi būti suderintos.

let ohStr = "Ohhh no";
// We want to match 'Oh's that have 3-6 'h' characters in it. let ohRegex = /Oh{3,6} no/;
let result = ohRegex.test(ohStr); // Returns true

27. Nurodykite tik mažesnį rungtynių skaičių

Kai norime nurodyti tik apatinę ribą, tai galime padaryti praleidę viršutinę ribą, pavyzdžiui, kad atitiktų bent tris simbolius, kuriuos galime parašyti {3,}. Atkreipkite dėmesį, kad mums vis tiek reikia kablelio, net jei nenurodome viršutinės ribos.

let haStr = "Hazzzzah";
// Match a pattern that contains at least for 'z' characterslet haRegex = /z{4,}/;
let result = haRegex.test(haStr); // Returns true

28. Nurodykite tikslų varžybų skaičių

Ankstesniame skyriuje minėjau, kad mums reikia kablelio, {3,}kai nurodome tik apatinę ribą. Priežastis yra ta, kai rašote {3}be kablelio, tai reiškia, kad ieškote tiksliai 3 simbolių.

let timStr = "Timmmmber";
// let timRegex = /Tim{4}ber/;
let result = timRegex.test(timStr); // Returns true

29. Patikrinkite, ar visi arba nėra

Kartais gali tekti nurodyti galimą simbolio egzistavimą savo šablone. Kai raidė ar skaičius yra neprivalomi ir mes tam naudotume ?.

// We want to match both British and American English spellings // of the word 'favourite'
let favWord_US = "favorite";let favWord_GB = "favourite";
// We match both 'favorite' and 'favourite' // by specifying that 'u' character is optionallet favRegex = /favou?rite/; // Change this line
let result1 = favRegex.test(favWord_US); // Returns truelet result2 = favRegex.test(favWord_GB); // Returns true

30. Teigiamas ir neigiamas žvilgsnis

Žvilgsnio galvutės “ yra šablonai, kurie liepia JS ieškoti žvilgsnio, kad patikrintų tolesnius modelius. Jie yra naudingi, kai bandote ieškoti kelių šablonų tose pačiose eilutėse. Yra 2 žvilgsnių tipai - teigiami ir neigiami.

Teigiamas žvilgsnis naudoja ?=sintaksę

let quit = "qu";
// We match 'q' only if it has 'u' after it. let quRegex= /q(?=u)/;
quit.match(quRegex); // Returns ["q"]

Neigiamajame žvilgsnyje naudojama ?!sintaksė

let noquit = "qt";
// We match 'q' only if there is no 'u' after it. let qRegex = /q(?!u)/;
noquit.match(qRegex); // Returns ["q"]

31. Pakartotinai naudokite šablonus naudodami fiksavimo grupes

Įsivaizduokime, kad turime užfiksuoti besikartojantį modelį.

let repeatStr = "regex regex";
// We want to match letters followed by space and then letterslet repeatRegex = /(\w+)\s(\w+)/;
repeatRegex.test(repeatStr); // Returns true

Užuot kartoję (\w+)pabaigoje, galime pasakyti „RegEx“ pakartoti modelį naudodami \1. Taigi tą patį, kas aukščiau, galima vėl parašyti taip:

let repeatStr = "regex regex";
let repeatRegex = /(\w+)\s\1)/;
repeatRegex.test(repeatStr); // Returns true

32. Naudokite „Capture Groups“, kad ieškotumėte ir pakeistumėte

Kai randame degtuką, kartais patogu pakeisti jį kuo nors kitu. Tam galime naudoti replace()metodą.

let wrongText = "The sky is silver.";
let silverRegex = /silver/;
wrongText.replace(silverRegex, "blue");
// Returns "The sky is blue."

33. Pašalinkite tarpą nuo pradžios ir pabaigos

Čia jums nedidelis iššūkis. Parašykite „RegEx“, kuris pašalintų visas eilutes aplink eilutę.

let hello = " Hello, World! ";
let wsRegex = /change/; // Change this line
let result = hello; // Change this line

Jei užstrigote ar tiesiog norite patikrinti mano sprendimą, drąsiai užmeskite akį į „Scrimba“ dalyvius, kur aš išsprendžiu šį iššūkį.

34. Išvada

Sveikiname! Baigėte šį kursą! Jei norite toliau mokytis daugiau, nedvejodami patikrinkite šį „YouTube“ grojaraštį, kuriame yra daugybė „JavaScript“ projektų, kuriuos galite sukurti.

Mokykis ir ačiū, kad skaitai!

Dabar esate pasirengę žaisti regex golfą. ?