Selle tasuta kursuse abil saate õppida regulaaravaldisi

"Mõned inimesed arvavad probleemiga silmitsi seistes:" Ma tean, ma kasutan regulaaravaldisi. " Nüüd on neil kaks probleemi. ” -Jamie Zawinski

Mõne inimese jaoks võib regulaaravaldiste kasutamine olla probleem. Kuid see ei pea olema teie jaoks probleem. See artikkel on regulaaravaldiste täielik kursus.

1. Sissejuhatus

Regulaaravaldisi või lihtsalt RegExi kasutatakse peaaegu kõigis programmeerimiskeeltes, et määratleda otsingumuster, mille abil saab stringist asju otsida.

Ma olen välja töötanud tasuta täieliku videokursuse veebisaidil Scrimba.com, et õpetada tavaväljendite põhitõdesid.

See artikkel sisaldab kursust kirjalikus vormis. Kuid kui eelistaksite vaadata interaktiivsete õppetundidega videoversiooni, saate seda vaadata Scrimba lehel. Selle artikli jaotised vastavad Scimba kursuse jaotistele.

See kursus järgneb koos RegExi õppekavaga aadressil freeCodeCamp.org. Saate seda kontrollida kodeerimisprobleemide ja sertifikaadi saamiseks.

Need õppetunnid keskenduvad RegExi kasutamisele JavaScriptis, kuid põhimõtted kehtivad paljudes teistes programmeerimiskeeltes, mille võite kasutada. Kui te ei tea veel JavaScripti, võib sellest abi olla, kui te selle kõigepealt pisut kajastate. Mul on ka JavaScripti baaskursus, millele pääseb juurde Scrimbas ja freeCodeCamp.org YouTube'i kanalil.

Nii et alustame! Säästate päeva mõne aja pärast. ?

2. Testimeetodi kasutamine

RegExi abil stringide osade sobitamiseks peame looma mustrid, mis aitavad teil seda sobitada. Saame näidata, et miski on RegExi muster, pannes mustri kaldkriipsude vahele /, nii /pattern-we-want-to-match/.

Vaatame näidet:

// 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/

Pange tähele, kuidas me /the/tähistame, et otsime oma sentence.

RegExi test()meetodi abil saame öelda, kas muster on stringis olemas või mitte.

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

3. Sobita sõnasõnalisi keeli

Leiame nüüd Waldo üles.

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);

Pange tähele, et selles näites waldoRegexon tõstutundlik, nii et kui kirjutaksime /waldo/väiketähega „w”, resultoleks meie väär.

4. Sobitage sõnasõnaline string erinevate võimalustega

RegExil on ka ORoperaator, mis on |märk.

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. Eirake juhtumit sobitamise ajal

Siiani oleme vaadanud mustreid, kui tähtede juhtum oli oluline. Kuidas saaksime oma RegExi mustrid muuta väiketähtede tundetuks?

Suurte ja iväikeste tähtede eiramiseks saame seda teha, lisades lipu mustri lõppu, nagu ka /some-pattern/i.

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

6. Eemaldage vasted

Kui tahame sobitada kokku sobivat väärtust, saame kasutada match()meetodit.

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. Leia rohkem kui esimene matš

Nüüd, kui teame, kuidas ühte väärtust välja võtta, on glipu abil võimalik ka mitu väärtust välja tõmmata

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

Saame ka glipu lipuga ühendada i, et välja tuua mitu vastet ja ignoreerida korpust.

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. Sobitage kõik metamärgi perioodiga

RegExis .on metamärk, mis sobiks kõigega.

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. Sobitage üks märk mitme võimalusega

Mis tahes tähemärgi sobitamine on tore, aga mis siis, kui soovime sobitamise piirata ettemääratud märkide komplektiga? Saame seda teha, kasutades []meie RegExi.

Kui meil on /b[aiu]g/, tähendab see, et saame sobitada 'kott', 'suur' ja 'viga'.

Kui tahame lausest välja tõmmata kõik täishäälikud, siis saame seda teha RegExi abil.

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. Sobivad tähestikud

Aga mis siis, kui soovime sobitada tähtede vahemikku? Muidugi, teeme seda.

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. Sobita tähestiku numbrid ja tähed

Tähed on head, aga mis siis, kui tahame ka numbreid?

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. Sobitage üksikuid märke, mis pole täpsustatud

Mõnikord on lihtsam määrata märke, mida te ei soovi vaadata. Neid nimetatakse negatiivseteks tähemärkideks ja RegExis saate seda teha kasutades ^.

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. Sobita tähemärke, mis esinevad üks või mitu korda

Kui soovite sobitada märke, mis esinevad üks või mitu korda, saate seda kasutada +.

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

14. Sobita tähemärke, mis toimuvad null või rohkem korda

Samuti on olemas *RegExi kvantor. See sobib isegi 0 tähemärgi esinemisega. Miks see võib olla kasulik? Enamasti on see tavaliselt koos teiste tähemärkidega. Vaatame ühte näidet.

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. Leidke Lazy Matchinguga tegelased

Mõnikord võib teie mustrivastetel olla mitu tulemust. Oletame näiteks, et otsin sõnas mustrit titanicja minu sobitatud väärtused peavad algama tähega „t” ja lõppema tähega „i”. Minu võimalikud tulemused on 'titani' ja 'ti'.

Sellepärast on RegExil mõisted "Ahne matš" ja "Laisk matš".

Ahne vaste leiab pikim võimalik mängu stringi, mis sobib RegEx muster, see on vaikimisi RegEx mängu:

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

Lazy vaste leiab võimalikult lühikese mängu stringi, mis sobib RegEx muster ja seda kasutada peame kasutama :?

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

16. Leidke jahist üks või mitu kurjategijat

Vaatame nüüd RegExi väljakutset. Me peame leidma kõik kurjategijad (C) rahvahulgast. Me teame, et nad püsivad alati koos ja peate kirjutama RegExi, mis neid leiaks.

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

Leiate mind selles Scrimba castis lahendusest läbi kõndimas.

17. Matši alguse stringimustrid

RegEx võimaldab sobitada ka mustreid, mis on alles stringi alguses. ^Eitava komplekti loomisest oleme juba rääkinud . Saame kasutada sama sümbolit vaste leidmiseks ainult stringi alguses.

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. Sobivad stringimustrid

Kuidas on stringi lõpus oleva mustri sobitamisega? Saame seda kasutada $.

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. Sobita kõik tähed ja numbrid

Varem osades 10 ja 11 näitasin teile, kuidas saame tähe- ja numbrivahemikke kokku sobitada. Kui ma paluksin teil kirjutada RegEx, mis sobib kõigi tähtede ja numbritega ning ignoreeriks nende juhtumeid, oleksite tõenäoliselt kirjutanud midagi sellist /[a-z0-9]/gija see on täpselt õige. Kuid see on natuke liiga pikk.

RegExil on midagi, mida nimetatakse "lühikeste tähemärkide klassideks" , mis on põhimõtteliselt tavalise RegExi avaldise lühikirjeldus. Kõigi kasutatavate tähtede ja numbrite sobitamiseks saame boonusena \wka alakriipsud _.

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. Sobita kõik, välja arvatud tähed ja numbrid

Kui tahame teha vastupidist ja sobitada kõike, mis pole täht või number (välista ka alakriips _), võime kasutada\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. Sobita kõik numbrid

Ok, mis siis, kui soovite ainult numbreid? Kas selleks on olemas lühikirjeldus? Muidugi on \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. Sobitage kõik mitte-numbrid

Kas soovite vastupidist ja sobitada kõik mitte-arvud? Kasutage\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. Piirake võimalikke kasutajanimesid

Siiamaani on kõik korras! Nii kaugele jõudmiseks on see hästi tehtud. RegEx võib olla keeruline, kuna see pole kõige hõlpsamini loetav viis kodeerimiseks. Vaatame nüüd väga reaalset näidet ja teeme kasutajanime valideerija. Sellisel juhul on teil 3 nõuet:

  • Kui on numbreid, peavad need olema lõpus.
  • Tähed võivad olla väikesed ja suured.
  • Vähemalt kaks tähemärki. Kahetähelistel nimedel ei tohi olla numbreid.

Proovige see ise lahendada ja kui teil on raske või soovite lihtsalt vastust kontrollida, vaadake minu lahendust.

24. Matš tühikuga

Kas me suudame sobitada kõik tühikud? Muidugi võime ka selleks kasutada lühikirjandit ja ongi\s

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

25. Sobitage mitte-tühimärgid

Kas oskate arvata, kuidas sobitada kõik tühimärgid? Hästi tehtud, see on \S!

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

26. Määrake vastete ülemine ja alumine arv

Mõõdikute alumise ja ülemise arvu saate määrata valiku „Koguse täpsustajad” abil. Neid saab kasutada näiteks {}süntaksiga, {3,6}kus 3on alumine piir ja 6ülemine piir, mis sobitatakse.

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. Määrake ainult väiksem vastete arv

Kui soovime määrata ainult alumise piiri, saame seda teha, jättes ülemise piiri välja, näiteks et sobitada vähemalt kolm tähemärki, mida saame kirjutada {3,}. Pange tähele, et koma vajame ikkagi, isegi kui me ei määra ülemist piiri.

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

28. Täpsustage vastete täpne arv

Eelmises osas mainisin, et vajame koma, {3,}kui määrame ainult alumise piiri. Põhjus on see, et kui kirjutate {3}komata, tähendab see, et otsite sobitada täpselt 3 tähemärki.

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

29. Kontrollige, kas kõik on või pole ühtegi

On olukordi, kus võiksite määratleda oma mustris märgi võimaliku olemasolu. Kui täht või number on valikuline ja me kasutaksime ?seda.

// 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. Positiivne ja negatiivne pilk

" Lookaheads " on mustrid, mis käskivad teie JSil otsida pead, et kontrollida mustreid veelgi. Need on kasulikud, kui proovite otsida mitu mustrit samadest stringidest. Seal on kahte tüüpi lookahead - positiivsed ja negatiivsed.

Positiivne välimus kasutab ?=süntaksit

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

Negatiivne välimus kasutab ?!süntaksit

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

31. Mustrite taaskasutamine püüdmisrühmade abil

Kujutame ette, et peame jäädvustama korduvat mustrit.

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

(\w+)Lõpus kordamise asemel võime RegExil käsu mustrit korrata, kasutades \1. Nii et ülaltoodu saab uuesti kirjutada järgmiselt:

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

32. Kasutage rühmade hõivamiseks otsimiseks ja asendamiseks

Kui leiame tiku, on mõnikord mugav see millegi muuga asendada. Selleks võime kasutada replace()meetodit.

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

33. Eemaldage tühik algusest ja lõpust

Siin on teile väike väljakutse. Kirjutage RegEx, mis eemaldaks stringi ümber kõik tühikud.

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

Kui jääd ummikusse või tahad lihtsalt minu lahendust kontrollida, viska julgelt pilk peale Scrimba näitlejatele, kus ma selle väljakutse lahendan.

34. Järeldus

Palju õnne! Olete selle kursuse lõpetanud! Kui soovite jätkata lisateavet, makske julgelt seda YouTube'i esitusloendit, kus on palju teie loodud JavaScripti projekte.

Jätka õppimist ja aitäh lugemast!

Nüüd olete valmis mängima regexi golfi. ?