Uzziniet parastās izteiksmes ar šo bezmaksas kursu

"Daži cilvēki, saskaroties ar problēmu, domā:" Es zinu, es izmantošu regulārus izteicienus ". Tagad viņiem ir divas problēmas. ” -Džamija Zavinski

Dažiem cilvēkiem parasto izteicienu lietošana var būt problēma. Bet tam nav jābūt jūsu problēmai. Šis raksts ir pilns regulāro izteicienu kurss.

1. Ievads

Regulārās izteiksmes vai vienkārši RegEx tiek izmantotas gandrīz visās programmēšanas valodās, lai definētu meklēšanas modeli, ko var izmantot, lai meklētu virknē esošās lietas.

Esmu izveidojis bezmaksas, pilnu video kursu vietnē Scrimba.com, lai mācītu regulāro izteicienu pamatus.

Šis raksts satur kursu rakstiskā formā. Bet, ja vēlaties skatīties video versiju ar interaktīvām nodarbībām, varat to pārbaudīt vietnē Scrimba. Šī raksta sadaļas atbilst Scimba kursa sadaļām.

Šis kurss seko kopā ar RegEx mācību programmu vietnē freeCodeCamp.org. Jūs varat pārbaudīt, vai nav kodēšanas problēmu un nopelnīt sertifikātu.

Šīs nodarbības koncentrējas uz RegEx izmantošanu JavaScript, taču principi attiecas uz daudzām citām programmēšanas valodām, kuras jūs varētu izvēlēties izmantot. Ja jūs vēl nezināt pamata JavaScriptu, tas varētu būt noderīgi, ja vispirms to nedaudz aptverat. Man ir arī pamata JavaScript kurss, kuram varat piekļūt Scrimba un freeCodeCamp.org YouTube kanālā.

Tātad sāksim! Jūs ietaupīsit dienu īsā laikā. ?

2. Pārbaudes metodes izmantošana

Lai saskaņotu virkņu daļas, izmantojot RegEx, mums ir jāizveido modeļi, kas palīdzēs jums veikt šo atbilstību. Mēs varam norādīt, ka kaut kas ir RegEx modelis, ievietojot modeli starp slīpsvītrām /, piemēram, tā /pattern-we-want-to-match/.

Apskatīsim piemēru:

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

Ievērojiet, kā mēs izmantojam, /the/lai norādītu, ka mēs meklējam “the” mūsu sentence.

Mēs varam izmantot RegEx test()metodi, lai noteiktu, vai virknē ir paraugs.

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

3. Sakrīt ar literārajām stīgām

Tagad atradīsim Valdo.

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

Ņemiet vērā, ka šajā piemērā waldoRegexreģistrjutīgi ir reģistrjutīgi burti, tādēļ, ja mēs rakstītu /waldo/ar mazajiem burtiem “w”, tad mūsu vārds resultbūtu aplams.

4. Saskaņojiet burtisko virkni ar dažādām iespējām

RegEx ir arī ORoperators, kas ir |raksturs.

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. Ignorējiet gadījumu, kad atrodat atbilstību

Līdz šim mēs esam apskatījuši modeļus, kad bija svarīga burtu lieta. Kā mēs varam padarīt mūsu RegEx modeļus reģistrjutīgus?

Lai ignorētu reģistru, mēs to varam izdarīt, pievienojot ikarodziņu modeļa beigās, piemēram, tā /some-pattern/i.

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

6. Izraksts sērkociņus

Kad mēs vēlamies iegūt saskaņoto vērtību, mēs varam izmantot match()metodi.

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. Atrodiet vairāk nekā pirmo maču

Tagad, kad mēs zinām, kā iegūt vienu vērtību, un ir iespējams arī iegūt vairākas vērtības, izmantojot gkarodziņu

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

Mēs varam arī apvienot gkarodziņu ar ikarodziņu, lai izvilktu vairākus sērkociņus un ignorētu apvalku.

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. Sakārtojiet jebko ar aizstājējzīmju periodu

In RegEx .ir aizstājējzīme, kas atbilstu jebko.

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. Saskaņojiet vienu rakstzīmi ar vairākām iespējām

Jebkuras rakstzīmes saskaņošana ir jauka, bet ko darīt, ja mēs vēlamies ierobežot atbilstību iepriekš noteiktai rakstzīmju kopai? Mēs to varam izdarīt, izmantojot []mūsu RegEx.

Ja mums tas ir /b[aiu]g/, tas nozīmē, ka mēs varam saskaņot “maisu”, “lielu” un “kļūdu”.

Ja mēs vēlamies no teikuma iegūt visus patskaņus, mēs to varam izdarīt, izmantojot 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. Sakritības alfabēta burti

Bet ko tad, ja mēs vēlamies saskaņot burtu diapazonu? Protams, darīsim to.

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. Sakritības skaitļi un alfabēta burti

Burti ir labi, bet ja nu mēs gribam arī skaitļus?

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. Sakrīt ar atsevišķām rakstzīmēm, kas nav norādītas

Dažreiz ir vieglāk norādīt rakstzīmes, kuras nevēlaties skatīties. Tos sauc par “Negated Characters”, un programmā RegEx to var izdarīt, izmantojot ^.

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. Atbilst rakstzīmes, kas notiek vienu vai vairākas reizes

Ja vēlaties saskaņot rakstzīmes, kas rodas vienu vai vairākas reizes, varat izmantot +.

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

14. Atbilst rakstzīmēm, kas notiek nulle vai vairāk reizes

Ir arī *RegEx kvantators. Šis atbilst pat 0 rakstzīmes gadījumiem. Kāpēc tas varētu būt noderīgi? Lielāko daļu laika tas parasti tiek kombinēts ar citām rakstzīmēm. Apskatīsim piemēru.

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. Atrodiet rakstzīmes ar Lazy Matching

Dažreiz jūsu modeļa atbilstībai var būt vairāki rezultāti. Piemēram, pieņemsim, ka es meklēju vārdu paraugu, titanicun manām saskaņotajām vērtībām jāsākas ar “t” un jābeidzas ar “i”. Mani iespējamie rezultāti ir “titani” un “ti”.

Tāpēc RegEx ir jēdzieni "mantkārīgs mačs" un "slinks mačs".

Mantkārīgā atbilstība atrod pēc iespējas garāku virknes atbilstību , kas atbilst RegEx modelim, šī ir noklusējuma RegEx atbilstība:

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

Lazy match atrod pēc iespējas īsāku virknes atbilstību , kas atbilst RegEx modelim, un, lai to izmantotu, mums jāizmanto ?:

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

16. Atrodiet vienu vai vairākus noziedzniekus medībās

Tagad apskatīsim RegEx izaicinājumu. Mums pūlī jāatrod visi noziedznieki ('C'). Mēs zinām, ka viņi vienmēr paliek kopā, un jums ir jāuzraksta RegEx, kas viņus atrastu.

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

Jūs varat atrast mani, ejot cauri risinājumam šajā Scrimba dalībniekiem.

17. Sērkociņu sākuma stīgu raksti

RegEx ļauj arī saskaņot modeļus, kas atrodas tikai virknes sākumā. Mēs jau runājām par ^noliedzoša komplekta izveidi. Mēs varam izmantot to pašu simbolu, lai atrastu atbilstību tikai virknes sākumā.

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. Sērkociņu beigu stīgu raksti

Kā ir ar modeļa atbilstību virknes galā? Mēs to varam izmantot $.

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. Sakrīt visas burti un cipari

Iepriekš 10. un 11. daļā es jums parādīju, kā mēs varam saskaņot burtu un ciparu diapazonus. Ja es jums lūgtu uzrakstīt RegEx, kas atbilst visiem burtiem un cipariem, un ignorētu to gadījumus, jūs, iespējams, būtu uzrakstījis kaut ko līdzīgu, /[a-z0-9]/giun tas ir tieši pareizi. Bet tas ir mazliet par ilgu.

RegEx ir kaut kas, ko sauc par Stenogrāfijas rakstzīmju klasēm” , kas būtībā ir parastās RegEx izteiksmes stenogrāfs. Lai saskaņotu visus burtus un ciparus, kurus mēs varam izmantot, \wmēs arī iegūstam pasvītrojumu, kas tiek _saskaņots kā bonuss.

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. Saskaņo visu, izņemot burtus un ciparus

Ja mēs vēlamies rīkoties pretēji un saskaņot visu, kas nav burts vai cipars (izslēdziet arī pasvītrojumu _), mēs varam izmantot\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. Atbilst visiem skaitļiem

Labi, kā ir, ja vēlaties tikai skaitļus? Vai tam ir stenogrāfijas rakstzīmju klase? Protams, tā ir \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. Saskaņojiet visus skaitļus, kas nav numuri

Vai jūs vēlētos pretējo un saskaņotu visus skaitļus, kas nav skaitļi? Izmantot\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. Ierobežot iespējamos lietotājvārdus

Tik tālu, labi! Labi darīts, lai tiktu tik tālu. RegEx var būt grūts, jo tas nav visvieglāk lasāms kodēšanas veids. Tagad aplūkosim ļoti reālu piemēru un izveidosim lietotājvārda validatoru. Šajā gadījumā jums ir 3 prasības:

  • Ja ir skaitļi, tiem jābūt beigās.
  • Burti var būt mazie un lielie.
  • Vismaz divu rakstzīmju garums. Divu burtu nosaukumos nedrīkst būt cipari.

Mēģiniet atrisināt to pats, un, ja jums tas ir grūti vai vienkārši vēlaties pārbaudīt atbildi, pārbaudiet manu risinājumu.

24. Spēlē Whitespace

Vai mēs varam saskaņot visas atstarpes? Protams, arī tam mēs varam izmantot stenogrāfiju, un tas ir\s

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

25. Atbilst rakstzīmēm, kas nav baltas vietas

Vai varat uzminēt, kā saskaņot visas rakstzīmes, kas nav atstarpes? Labi darīts, tas ir \S!

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

26. Norādiet augšējo un apakšējo sērkociņu skaitu

Izmantojot 'Daudzuma specifikatori', varat norādīt apakšējo un augšējo rakstu atbilstību skaitu . Tos var izmantot {}, piemēram {3,6}, ar sintaksi, kur 3ir 6saskaņojama apakšējā un augšējā robeža.

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. Norādiet tikai mazāko sērkociņu skaitu

Kad mēs vēlamies norādīt tikai apakšējo robežu, mēs to varam izdarīt, izlaižot augšējo robežu, piemēram, lai saskaņotu vismaz trīs rakstzīmes, kuras mēs varam rakstīt {3,}. Ievērojiet, ka mums joprojām ir nepieciešams komats, pat ja mēs nenorādām augšējo robežu.

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

28. Norādiet precīzu sērkociņu skaitu

Iepriekšējā sadaļā es minēju, ka mums ir nepieciešams komats, {3,}kad mēs norādām tikai apakšējo robežu. Iemesls ir tas, ka, rakstot {3}bez komata, tas nozīmē, ka jūs meklējat tieši 3 rakstzīmes.

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

29. Pārbaudiet, vai visi vai nav

Ir reizes, kad jūs varētu vēlēties norādīt iespējamo rakstzīmes esamību savā modelī. Kad burts vai cipars nav obligāti, un mēs to izmantosim ?.

// 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. Pozitīvs un negatīvs skatiens

" Lookaheads " ir modeļi, kas liek jūsu JS meklēt lookead, lai pārbaudītu, vai modeļi atrodas tālāk. Tie ir noderīgi, ja mēģināt meklēt vairākus modeļus vienā un tajā pašā virknē. Tur ir 2 veidu uzmavas - pozitīvas un negatīvas.

Pozitīvajā uzmeklē tiek izmantota ?=sintakse

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

Negatīvā uzmava izmanto ?!sintaksi

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

31. Atkārtoti izmantojiet modeļus, izmantojot tveršanas grupas

Iedomāsimies, ka mums ir jāaptver atkārtots modelis.

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

Tā vietā, lai atkārtotu (\w+)beigās, mēs varam pateikt RegEx atkārtot modeli, izmantojot \1. Tātad to pašu, ko iepriekš var atkārtoti uzrakstīt kā:

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

32. Izmantojiet Capture Groups, lai meklētu un aizstātu

Kad atrodam sērkociņu, dažreiz ir ērti to aizstāt ar ko citu. Mēs tam varam izmantot replace()metodi.

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

33. Noņemiet atstarpi no sākuma un beigām

Lūk, neliels izaicinājums jums. Uzrakstiet RegEx, kas noņemtu visas atstarpes ap virkni.

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

Ja jūs iestrēgstat vai vienkārši vēlaties pārbaudīt manu risinājumu, nekautrējieties apskatīt Scrimba dalībniekus, kur es atrisinu šo izaicinājumu.

34. Secinājums

Apsveicam! Jūs esat pabeidzis šo kursu! Ja vēlaties turpināt uzzināt vairāk, apmeklējiet šo YouTube atskaņošanas sarakstu, kurā ir daudz JavaScript projektu, kurus varat izveidot.

Turpini mācīties un paldies par lasīšanu!

Tagad esat gatavs spēlēt regulāru golfu. ?