ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ಸ್ ಬಳಸಿ ಸುಧಾರಿತ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪ್ಯಾಟರ್ನ್ ಮ್ಯಾಚಿಂಗ್ ಅನ್ವೇಷಿಸಿ. ರೆಜೆಕ್ಸ್ ಸಿಂಟ್ಯಾಕ್ಸ್, ಪ್ರಾಯೋಗಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಮತ್ತು ದಕ್ಷ ಹಾಗೂ ದೃಢವಾದ ಕೋಡ್‌ಗಾಗಿ ಆಪ್ಟಿಮೈಸೇಶನ್ ತಂತ್ರಗಳನ್ನು ಕಲಿಯಿರಿ.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪ್ಯಾಟರ್ನ್ ಮ್ಯಾಚಿಂಗ್ ಮತ್ತು ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ಸ್: ಒಂದು ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ
ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳು (ರೆಜೆಕ್ಸ್) ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಪ್ಯಾಟರ್ನ್ ಮ್ಯಾಚಿಂಗ್ ಮತ್ತು ಟೆಕ್ಸ್ಟ್ ಮ್ಯಾನಿಪುಲೇಷನ್‌ಗಾಗಿ ಒಂದು ಶಕ್ತಿಯುತ ಸಾಧನವಾಗಿದೆ. ಇವುಗಳು ಡೆವಲಪರ್‌ಗಳಿಗೆ ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಪ್ಯಾಟರ್ನ್‌ಗಳ ಆಧಾರದ ಮೇಲೆ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಹುಡುಕಲು, ಮೌಲ್ಯೀಕರಿಸಲು ಮತ್ತು ಪರಿವರ್ತಿಸಲು ಅನುಮತಿಸುತ್ತವೆ. ಈ ಮಾರ್ಗದರ್ಶಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿನ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳ ಸಮಗ್ರ ಅವಲೋಕನವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದು ಸಿಂಟ್ಯಾಕ್ಸ್, ಬಳಕೆ ಮತ್ತು ಸುಧಾರಿತ ತಂತ್ರಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.
ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳು ಎಂದರೇನು?
ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಎನ್ನುವುದು ಸರ್ಚ್ ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುವ ಅಕ್ಷರಗಳ ಸರಣಿಯಾಗಿದೆ. ಈ ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಹೊಂದಿಸಲು ಮತ್ತು ಬದಲಾಯಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳನ್ನು ಈ ಕೆಳಗಿನ ಕಾರ್ಯಗಳಿಗಾಗಿ ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ:
- ಡೇಟಾ ವ್ಯಾಲಿಡೇಶನ್: ಬಳಕೆದಾರರ ಇನ್‌ಪುಟ್ ನಿರ್ದಿಷ್ಟ ಫಾರ್ಮ್ಯಾಟ್‌ಗಳಿಗೆ (ಉದಾ. ಇಮೇಲ್ ವಿಳಾಸಗಳು, ಫೋನ್ ಸಂಖ್ಯೆಗಳು) ಅನುಗುಣವಾಗಿದೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು.
- ಡೇಟಾ ಎಕ್ಸ್‌ಟ್ರಾಕ್ಷನ್: ಟೆಕ್ಸ್ಟ್‌ನಿಂದ ನಿರ್ದಿಷ್ಟ ಮಾಹಿತಿಯನ್ನು ಹಿಂಪಡೆಯುವುದು (ಉದಾ. ದಿನಾಂಕಗಳು, URLಗಳು, ಅಥವಾ ಬೆಲೆಗಳನ್ನು ಹೊರತೆಗೆಯುವುದು).
- ಸರ್ಚ್ ಮತ್ತು ರಿಪ್ಲೇಸ್: ಸಂಕೀರ್ಣ ಪ್ಯಾಟರ್ನ್‌ಗಳ ಆಧಾರದ ಮೇಲೆ ಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಹುಡುಕುವುದು ಮತ್ತು ಬದಲಾಯಿಸುವುದು.
- ಟೆಕ್ಸ್ಟ್ ಪ್ರೊಸೆಸಿಂಗ್: ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ನಿಯಮಗಳ ಆಧಾರದ ಮೇಲೆ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ವಿಭಜಿಸುವುದು, ಸೇರಿಸುವುದು ಅಥವಾ ಪರಿವರ್ತಿಸುವುದು.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳನ್ನು ರಚಿಸುವುದು
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳನ್ನು ಎರಡು ರೀತಿಯಲ್ಲಿ ರಚಿಸಬಹುದು:
- ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಲಿಟರಲ್ ಬಳಸಿ: ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಫಾರ್ವರ್ಡ್ ಸ್ಲ್ಯಾಷ್‌ಗಳ (
/) ಒಳಗೆ ಇರಿಸಿ. RegExpಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಬಳಸಿ: ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಸ್ಟ್ರಿಂಗ್ ಆಗಿ ಬಳಸಿRegExpಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸಿ.
ಉದಾಹರಣೆ:
// ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಲಿಟರಲ್ ಬಳಸಿ
const regexLiteral = /hello/;
// RegExp ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಬಳಸಿ
const regexConstructor = new RegExp("hello");
ಎರಡು ವಿಧಾನಗಳ ನಡುವಿನ ಆಯ್ಕೆಯು ಪ್ಯಾಟರ್ನ್ ಕಂಪೈಲ್ ಸಮಯದಲ್ಲಿ ತಿಳಿದಿದೆಯೇ ಅಥವಾ ಡೈನಾಮಿಕ್ ಆಗಿ ರಚಿಸಲ್ಪಟ್ಟಿದೆಯೇ ಎಂಬುದರ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರುತ್ತದೆ. ಪ್ಯಾಟರ್ನ್ ಸ್ಥಿರವಾಗಿದ್ದಾಗ ಮತ್ತು ಮುಂಚಿತವಾಗಿ ತಿಳಿದಿರುವಾಗ ಲಿಟರಲ್ ಸಂಕೇತವನ್ನು ಬಳಸಿ. ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಪ್ರೋಗ್ರಾಮ್ಯಾಟಿಕ್ ಆಗಿ ನಿರ್ಮಿಸಬೇಕಾದಾಗ, ವಿಶೇಷವಾಗಿ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಸಂಯೋಜಿಸುವಾಗ ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್ ಅನ್ನು ಬಳಸಿ.
ಮೂಲಭೂತ ರೆಜೆಕ್ಸ್ ಸಿಂಟ್ಯಾಕ್ಸ್
ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳು ಹೊಂದಾಣಿಕೆಯಾಗಬೇಕಾದ ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಅಕ್ಷರಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ. ಕೆಲವು ಮೂಲಭೂತ ರೆಜೆಕ್ಸ್ ಘಟಕಗಳು ಇಲ್ಲಿವೆ:
- ಲಿಟರಲ್ ಕ್ಯಾರೆಕ್ಟರ್ಸ್: ಅಕ್ಷರಗಳನ್ನು ಹಾಗೆಯೇ ಹೊಂದಿಸುತ್ತದೆ (ಉದಾ.
/a/'a' ಅಕ್ಷರವನ್ನು ಹೊಂದಿಸುತ್ತದೆ). - ಮೆಟಾಕ್ಯಾರೆಕ್ಟರ್ಸ್: ವಿಶೇಷ ಅರ್ಥಗಳನ್ನು ಹೊಂದಿವೆ (ಉದಾ.
.,^,$,*,+,?,[],{},(),\,|). - ಕ್ಯಾರೆಕ್ಟರ್ ಕ್ಲಾಸಸ್: ಅಕ್ಷರಗಳ ಗುಂಪುಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ (ಉದಾ.
[abc]'a', 'b', ಅಥವಾ 'c' ಅನ್ನು ಹೊಂದಿಸುತ್ತದೆ). - ಕ್ವಾಂಟಿಫೈಯರ್ಸ್: ಒಂದು ಅಕ್ಷರ ಅಥವಾ ಗುಂಪು ಎಷ್ಟು ಬಾರಿ ಬರಬೇಕು ಎಂಬುದನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತವೆ (ಉದಾ.
*,+,?,{n},{n,},{n,m}). - ಆಂಕರ್ಸ್: ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿನ ಸ್ಥಾನಗಳನ್ನು ಹೊಂದಿಸುತ್ತವೆ (ಉದಾ.
^ಆರಂಭವನ್ನು ಹೊಂದಿಸುತ್ತದೆ,$ಅಂತ್ಯವನ್ನು ಹೊಂದಿಸುತ್ತದೆ).
ಸಾಮಾನ್ಯ ಮೆಟಾಕ್ಯಾರೆಕ್ಟರ್ಸ್:
.(ಡಾಟ್): ನ್ಯೂಲೈನ್ ಹೊರತುಪಡಿಸಿ ಯಾವುದೇ ಒಂದೇ ಅಕ್ಷರವನ್ನು ಹೊಂದಿಸುತ್ತದೆ.^(ಕ್ಯಾರೆಟ್): ಸ್ಟ್ರಿಂಗ್‌ನ ಆರಂಭವನ್ನು ಹೊಂದಿಸುತ್ತದೆ.$(ಡಾಲರ್): ಸ್ಟ್ರಿಂಗ್‌ನ ಅಂತ್ಯವನ್ನು ಹೊಂದಿಸುತ್ತದೆ.*(ಆಸ್ಟರಿಸ್ಕ್): ಹಿಂದಿನ ಅಕ್ಷರ ಅಥವಾ ಗುಂಪಿನ ಶೂನ್ಯ ಅಥವಾ ಹೆಚ್ಚಿನ ಸಂಭವಗಳನ್ನು ಹೊಂದಿಸುತ್ತದೆ.+(ಪ್ಲಸ್): ಹಿಂದಿನ ಅಕ್ಷರ ಅಥವಾ ಗುಂಪಿನ ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ ಸಂಭವಗಳನ್ನು ಹೊಂದಿಸುತ್ತದೆ.?(ಪ್ರಶ್ನಾರ್ಥಕ ಚಿಹ್ನೆ): ಹಿಂದಿನ ಅಕ್ಷರ ಅಥವಾ ಗುಂಪಿನ ಶೂನ್ಯ ಅಥವಾ ಒಂದು ಸಂಭವವನ್ನು ಹೊಂದಿಸುತ್ತದೆ. ಐಚ್ಛಿಕ ಅಕ್ಷರಗಳಿಗಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.[](ಸ್ಕ್ವೇರ್ ಬ್ರಾಕೆಟ್ಸ್): ಒಂದು ಅಕ್ಷರ ವರ್ಗವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ, ಬ್ರಾಕೆಟ್‌ಗಳೊಳಗಿನ ಯಾವುದೇ ಒಂದೇ ಅಕ್ಷರವನ್ನು ಹೊಂದಿಸುತ್ತದೆ.{}(ಕರ್ಲಿ ಬ್ರೇಸಸ್): ಹೊಂದಾಣಿಕೆಯಾಗಬೇಕಾದ ಸಂಭವಗಳ ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.{n}ನಿಖರವಾಗಿ n ಬಾರಿ ಹೊಂದಿಸುತ್ತದೆ,{n,}n ಅಥವಾ ಅದಕ್ಕಿಂತ ಹೆಚ್ಚು ಬಾರಿ ಹೊಂದಿಸುತ್ತದೆ,{n,m}n ಮತ್ತು m ನಡುವಿನ ಬಾರಿ ಹೊಂದಿಸುತ್ತದೆ.()(ಪ್ಯಾರೆಂಥೆಸಿಸ್): ಅಕ್ಷರಗಳನ್ನು ಒಟ್ಟಿಗೆ ಗುಂಪು ಮಾಡುತ್ತದೆ ಮತ್ತು ಹೊಂದಾಣಿಕೆಯಾದ ಸಬ್‌ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಕ್ಯಾಪ್ಚರ್ ಮಾಡುತ್ತದೆ.\(ಬ್ಯಾಕ್‌ಸ್ಲ್ಯಾಷ್): ಮೆಟಾಕ್ಯಾರೆಕ್ಟರ್‌ಗಳನ್ನು ಎಸ್ಕೇಪ್ ಮಾಡುತ್ತದೆ, ಅವುಗಳನ್ನು ಅಕ್ಷರಶಃ ಹೊಂದಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.|(ಪೈಪ್): "or" ಆಪರೇಟರ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಅದರ ಮೊದಲು ಅಥವಾ ನಂತರದ ಅಭಿವ್ಯಕ್ತಿಯನ್ನು ಹೊಂದಿಸುತ್ತದೆ.
ಕ್ಯಾರೆಕ್ಟರ್ ಕ್ಲಾಸಸ್:
[abc]: a, b, ಅಥವಾ c ಅಕ್ಷರಗಳಲ್ಲಿ ಯಾವುದಾದರೂ ಒಂದನ್ನು ಹೊಂದಿಸುತ್ತದೆ.[^abc]: a, b, ಅಥವಾ c *ಅಲ್ಲದ* ಯಾವುದೇ ಅಕ್ಷರವನ್ನು ಹೊಂದಿಸುತ್ತದೆ.[a-z]: a ನಿಂದ z ವರೆಗಿನ ಯಾವುದೇ ಸಣ್ಣಕ್ಷರವನ್ನು ಹೊಂದಿಸುತ್ತದೆ.[A-Z]: A ನಿಂದ Z ವರೆಗಿನ ಯಾವುದೇ ದೊಡ್ಡಕ್ಷರವನ್ನು ಹೊಂದಿಸುತ್ತದೆ.[0-9]: 0 ರಿಂದ 9 ರವರೆಗಿನ ಯಾವುದೇ ಅಂಕಿಯನ್ನು ಹೊಂದಿಸುತ್ತದೆ.[a-zA-Z0-9]: ಯಾವುದೇ ಆಲ್ಫಾನ್ಯೂಮರಿಕ್ ಅಕ್ಷರವನ್ನು ಹೊಂದಿಸುತ್ತದೆ.\d: ಯಾವುದೇ ಅಂಕಿಯನ್ನು ಹೊಂದಿಸುತ್ತದೆ ([0-9]ಗೆ ಸಮಾನ).\D: ಯಾವುದೇ ಅಂಕಿ ಅಲ್ಲದ ಅಕ್ಷರವನ್ನು ಹೊಂದಿಸುತ್ತದೆ ([^0-9]ಗೆ ಸಮಾನ).\w: ಯಾವುದೇ ಪದದ ಅಕ್ಷರವನ್ನು ಹೊಂದಿಸುತ್ತದೆ (ಆಲ್ಫಾನ್ಯೂಮರಿಕ್ ಜೊತೆಗೆ ಅಂಡರ್‌ಸ್ಕೋರ್;[a-zA-Z0-9_]ಗೆ ಸಮಾನ).\W: ಯಾವುದೇ ಪದವಲ್ಲದ ಅಕ್ಷರವನ್ನು ಹೊಂದಿಸುತ್ತದೆ ([^a-zA-Z0-9_]ಗೆ ಸಮಾನ).\s: ಯಾವುದೇ ವೈಟ್‌ಸ್ಪೇಸ್ ಅಕ್ಷರವನ್ನು ಹೊಂದಿಸುತ್ತದೆ (ಸ್ಪೇಸ್, ಟ್ಯಾಬ್, ನ್ಯೂಲೈನ್, ಇತ್ಯಾದಿ).\S: ಯಾವುದೇ ವೈಟ್‌ಸ್ಪೇಸ್ ಅಲ್ಲದ ಅಕ್ಷರವನ್ನು ಹೊಂದಿಸುತ್ತದೆ.
ಕ್ವಾಂಟಿಫೈಯರ್ಸ್:
*: ಹಿಂದಿನ ಅಂಶವನ್ನು ಶೂನ್ಯ ಅಥವಾ ಹೆಚ್ಚು ಬಾರಿ ಹೊಂದಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ,a*"", "a", "aa", "aaa", ಇತ್ಯಾದಿಗಳನ್ನು ಹೊಂದಿಸುತ್ತದೆ.+: ಹಿಂದಿನ ಅಂಶವನ್ನು ಒಂದು ಅಥವಾ ಹೆಚ್ಚು ಬಾರಿ ಹೊಂದಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ,a+"a", "aa", "aaa" ಅನ್ನು ಹೊಂದಿಸುತ್ತದೆ, ಆದರೆ "" ಅನ್ನು ಅಲ್ಲ.?: ಹಿಂದಿನ ಅಂಶವನ್ನು ಶೂನ್ಯ ಅಥವಾ ಒಂದು ಬಾರಿ ಹೊಂದಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ,a?"" ಅಥವಾ "a" ಅನ್ನು ಹೊಂದಿಸುತ್ತದೆ.{n}: ಹಿಂದಿನ ಅಂಶವನ್ನು ನಿಖರವಾಗಿ *n* ಬಾರಿ ಹೊಂದಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ,a{3}"aaa" ಅನ್ನು ಹೊಂದಿಸುತ್ತದೆ.{n,}: ಹಿಂದಿನ ಅಂಶವನ್ನು *n* ಅಥವಾ ಹೆಚ್ಚು ಬಾರಿ ಹೊಂದಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ,a{2,}"aa", "aaa", "aaaa", ಇತ್ಯಾದಿಗಳನ್ನು ಹೊಂದಿಸುತ್ತದೆ.{n,m}: ಹಿಂದಿನ ಅಂಶವನ್ನು *n* ಮತ್ತು *m* ನಡುವಿನ ಬಾರಿ (ಸೇರಿದಂತೆ) ಹೊಂದಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ,a{2,4}"aa", "aaa", ಅಥವಾ "aaaa" ಅನ್ನು ಹೊಂದಿಸುತ್ತದೆ.
ಆಂಕರ್ಸ್:
^: ಸ್ಟ್ರಿಂಗ್‌ನ ಆರಂಭವನ್ನು ಹೊಂದಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ,^Hello"Hello" ದಿಂದ *ಪ್ರಾರಂಭವಾಗುವ* ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಹೊಂದಿಸುತ್ತದೆ.$: ಸ್ಟ್ರಿಂಗ್‌ನ ಅಂತ್ಯವನ್ನು ಹೊಂದಿಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ,World$"World" ದಿಂದ *ಕೊನೆಗೊಳ್ಳುವ* ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಹೊಂದಿಸುತ್ತದೆ.\b: ಪದದ ಗಡಿಯನ್ನು ಹೊಂದಿಸುತ್ತದೆ. ಇದು ಪದದ ಅಕ್ಷರ (\w) ಮತ್ತು ಪದವಲ್ಲದ ಅಕ್ಷರ (\W) ಅಥವಾ ಸ್ಟ್ರಿಂಗ್‌ನ ಆರಂಭ ಅಥವಾ ಅಂತ್ಯದ ನಡುವಿನ ಸ್ಥಾನವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ,\bword\b"word" ಎಂಬ ಸಂಪೂರ್ಣ ಪದವನ್ನು ಹೊಂದಿಸುತ್ತದೆ.
ಫ್ಲಾಗ್ಸ್:
ರೆಜೆಕ್ಸ್ ಫ್ಲಾಗ್‌ಗಳು ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳ ನಡವಳಿಕೆಯನ್ನು ಮಾರ್ಪಡಿಸುತ್ತವೆ. ಅವುಗಳನ್ನು ರೆಜೆಕ್ಸ್ ಲಿಟರಲ್‌ನ ಕೊನೆಯಲ್ಲಿ ಸೇರಿಸಲಾಗುತ್ತದೆ ಅಥವಾ RegExp ಕನ್‌ಸ್ಟ್ರಕ್ಟರ್‌ಗೆ ಎರಡನೇ ಆರ್ಗ್ಯುಮೆಂಟ್ ಆಗಿ ರವಾನಿಸಲಾಗುತ್ತದೆ.
g(ಗ್ಲೋಬಲ್): ಪ್ಯಾಟರ್ನ್‌ನ ಎಲ್ಲಾ ಸಂಭವಗಳನ್ನು ಹೊಂದಿಸುತ್ತದೆ, ಕೇವಲ ಮೊದಲನೆಯದನ್ನು ಅಲ್ಲ.i(ಇಗ್ನೋರ್ ಕೇಸ್): ಕೇಸ್-ಇನ್‌ಸೆನ್ಸಿಟಿವ್ ಮ್ಯಾಚಿಂಗ್ ಮಾಡುತ್ತದೆ.m(ಮಲ್ಟಿಲೈನ್): ಮಲ್ಟಿಲೈನ್ ಮೋಡ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ, ಅಲ್ಲಿ^ಮತ್ತು$ಪ್ರತಿ ಸಾಲಿನ ಆರಂಭ ಮತ್ತು ಅಂತ್ಯವನ್ನು ಹೊಂದಿಸುತ್ತದೆ (\nನಿಂದ ಬೇರ್ಪಡಿಸಲಾಗಿದೆ).s(ಡಾಟ್ಆಲ್): ಡಾಟ್ (.) ನ್ಯೂಲೈನ್ ಅಕ್ಷರಗಳನ್ನು ಸಹ ಹೊಂದಿಸಲು ಅನುಮತಿಸುತ್ತದೆ.u(ಯೂನಿಕೋಡ್): ಪೂರ್ಣ ಯೂನಿಕೋಡ್ ಬೆಂಬಲವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ.y(ಸ್ಟಿಕಿ): ರೆಜೆಕ್ಸ್‌ನlastIndexಪ್ರಾಪರ್ಟಿಯಿಂದ ಸೂಚಿಸಲಾದ ಇಂಡೆಕ್ಸ್‌ನಿಂದ ಮಾತ್ರ ಹೊಂದಿಸುತ್ತದೆ.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ರೆಜೆಕ್ಸ್ ಮೆಥಡ್ಸ್
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಹಲವಾರು ಮೆಥಡ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ:
test(): ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಪ್ಯಾಟರ್ನ್‌ಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆಯೇ ಎಂದು ಪರೀಕ್ಷಿಸುತ್ತದೆ.trueಅಥವಾfalseಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.exec(): ಒಂದು ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಹೊಂದಾಣಿಕೆಗಾಗಿ ಹುಡುಕಾಟವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ. ಹೊಂದಾಣಿಕೆಯಾದ ಟೆಕ್ಸ್ಟ್ ಮತ್ತು ಕ್ಯಾಪ್ಚರ್ ಮಾಡಿದ ಗುಂಪುಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಅರೇಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಅಥವಾ ಯಾವುದೇ ಹೊಂದಾಣಿಕೆ ಕಂಡುಬರದಿದ್ದರೆnullಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.match(): ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗೆ ಹೊಂದಿಸಿದ ಫಲಿತಾಂಶಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಅರೇಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.gಫ್ಲಾಗ್‌ನೊಂದಿಗೆ ಮತ್ತು ಇಲ್ಲದೆ ವಿಭಿನ್ನವಾಗಿ ವರ್ತಿಸುತ್ತದೆ.search(): ಒಂದು ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಹೊಂದಾಣಿಕೆಗಾಗಿ ಪರೀಕ್ಷಿಸುತ್ತದೆ. ಮೊದಲ ಹೊಂದಾಣಿಕೆಯ ಇಂಡೆಕ್ಸ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಅಥವಾ ಯಾವುದೇ ಹೊಂದಾಣಿಕೆ ಕಂಡುಬರದಿದ್ದರೆ -1 ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ.replace(): ಪ್ಯಾಟರ್ನ್‌ನ ಸಂಭವಗಳನ್ನು ಬದಲಿ ಸ್ಟ್ರಿಂಗ್ ಅಥವಾ ಬದಲಿ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸುವ ಫಂಕ್ಷನ್‌ನೊಂದಿಗೆ ಬದಲಾಯಿಸುತ್ತದೆ.split(): ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ ಆಧಾರದ ಮೇಲೆ ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಸಬ್‌ಸ್ಟ್ರಿಂಗ್‌ಗಳ ಅರೇ ಆಗಿ ವಿಭಜಿಸುತ್ತದೆ.
ರೆಜೆಕ್ಸ್ ಮೆಥಡ್‌ಗಳನ್ನು ಬಳಸುವ ಉದಾಹರಣೆಗಳು:
// test()
const regex = /hello/;
const str = "hello world";
console.log(regex.test(str)); // ಔಟ್‌ಪುಟ್: true
// exec()
const regex2 = /hello (\w+)/;
const str2 = "hello world";
const result = regex2.exec(str2);
console.log(result); // ಔಟ್‌ಪುಟ್: ["hello world", "world", index: 0, input: "hello world", groups: undefined]
// 'g' ಫ್ಲಾಗ್‌ನೊಂದಿಗೆ match()
const regex3 = /\d+/g; // ಜಾಗತಿಕವಾಗಿ ಒಂದು ಅಥವಾ ಹೆಚ್ಚು ಅಂಕಿಗಳನ್ನು ಹೊಂದಿಸುತ್ತದೆ
const str3 = "There are 123 apples and 456 oranges.";
const matches = str3.match(regex3);
console.log(matches); // ಔಟ್‌ಪುಟ್: ["123", "456"]
// 'g' ಫ್ಲಾಗ್ ಇಲ್ಲದೆ match()
const regex4 = /\d+/;
const str4 = "There are 123 apples and 456 oranges.";
const match = str4.match(regex4);
console.log(match); // ಔಟ್‌ಪುಟ್: ["123", index: 11, input: "There are 123 apples and 456 oranges.", groups: undefined]
// search()
const regex5 = /world/;
const str5 = "hello world";
console.log(str5.search(regex5)); // ಔಟ್‌ಪುಟ್: 6
// replace()
const regex6 = /world/;
const str6 = "hello world";
const newStr = str6.replace(regex6, "JavaScript");
console.log(newStr); // ಔಟ್‌ಪುಟ್: hello JavaScript
// ಫಂಕ್ಷನ್‌ನೊಂದಿಗೆ replace()
const regex7 = /(\d+)-(\d+)-(\d+)/;
const str7 = "Today's date is 2023-10-27";
const newStr2 = str7.replace(regex7, (match, year, month, day) => {
return `${day}/${month}/${year}`;
});
console.log(newStr2); // ಔಟ್‌ಪುಟ್: Today's date is 27/10/2023
// split()
const regex8 = /, /;
const str8 = "apple, banana, cherry";
const arr = str8.split(regex8);
console.log(arr); // ಔಟ್‌ಪುಟ್: ["apple", "banana", "cherry"]
ಸುಧಾರಿತ ರೆಜೆಕ್ಸ್ ತಂತ್ರಗಳು
ಕ್ಯಾಪ್ಚರಿಂಗ್ ಗ್ರೂಪ್ಸ್:
ಪ್ಯಾರೆಂಥೆಸಿಸ್ () ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳಲ್ಲಿ ಕ್ಯಾಪ್ಚರಿಂಗ್ ಗ್ರೂಪ್‌ಗಳನ್ನು ರಚಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಕ್ಯಾಪ್ಚರ್ ಮಾಡಲಾದ ಗ್ರೂಪ್‌ಗಳು ಹೊಂದಾಣಿಕೆಯಾದ ಟೆಕ್ಸ್ಟ್‌ನ ನಿರ್ದಿಷ್ಟ ಭಾಗಗಳನ್ನು ಹೊರತೆಗೆಯಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತವೆ. exec() ಮತ್ತು match() ಮೆಥಡ್‌ಗಳು ಒಂದು ಅರೇಯನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತವೆ, ಅಲ್ಲಿ ಮೊದಲ ಅಂಶವು ಸಂಪೂರ್ಣ ಹೊಂದಾಣಿಕೆಯಾಗಿರುತ್ತದೆ ಮತ್ತು ನಂತರದ ಅಂಶಗಳು ಕ್ಯಾಪ್ಚರ್ ಮಾಡಲಾದ ಗ್ರೂಪ್‌ಗಳಾಗಿರುತ್ತವೆ.
const regex = /(\d{4})-(\d{2})-(\d{2})/;
const dateString = "2023-10-27";
const match = regex.exec(dateString);
console.log(match[0]); // ಔಟ್‌ಪುಟ್: 2023-10-27 (ಸಂಪೂರ್ಣ ಹೊಂದಾಣಿಕೆ)
console.log(match[1]); // ಔಟ್‌ಪುಟ್: 2023 (ಮೊದಲ ಕ್ಯಾಪ್ಚರ್ ಮಾಡಿದ ಗ್ರೂಪ್ - ವರ್ಷ)
console.log(match[2]); // ಔಟ್‌ಪುಟ್: 10 (ಎರಡನೇ ಕ್ಯಾಪ್ಚರ್ ಮಾಡಿದ ಗ್ರೂಪ್ - ತಿಂಗಳು)
console.log(match[3]); // ಔಟ್‌ಪುಟ್: 27 (ಮೂರನೇ ಕ್ಯಾಪ್ಚರ್ ಮಾಡಿದ ಗ್ರೂಪ್ - ದಿನ)
ನೇಮ್ಡ್ ಕ್ಯಾಪ್ಚರಿಂಗ್ ಗ್ರೂಪ್ಸ್:
ES2018 ನೇಮ್ಡ್ ಕ್ಯಾಪ್ಚರಿಂಗ್ ಗ್ರೂಪ್‌ಗಳನ್ನು ಪರಿಚಯಿಸಿತು, ಇದು (? ಸಿಂಟ್ಯಾಕ್ಸ್ ಬಳಸಿ ಕ್ಯಾಪ್ಚರಿಂಗ್ ಗ್ರೂಪ್‌ಗಳಿಗೆ ಹೆಸರುಗಳನ್ನು ನಿಯೋಜಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಇದು ಕೋಡ್ ಅನ್ನು ಹೆಚ್ಚು ಓದಬಲ್ಲ ಮತ್ತು ನಿರ್ವಹಿಸಬಲ್ಲಂತೆ ಮಾಡುತ್ತದೆ.
const regex = /(?\d{4})-(?\d{2})-(?\d{2})/;
const dateString = "2023-10-27";
const match = regex.exec(dateString);
console.log(match.groups.year); // ಔಟ್‌ಪುಟ್: 2023
console.log(match.groups.month); // ಔಟ್‌ಪುಟ್: 10
console.log(match.groups.day); // ಔಟ್‌ಪುಟ್: 27
ನಾನ್-ಕ್ಯಾಪ್ಚರಿಂಗ್ ಗ್ರೂಪ್ಸ್:
ನೀವು ರೆಜೆಕ್ಸ್‌ನ ಭಾಗಗಳನ್ನು ಕ್ಯಾಪ್ಚರ್ ಮಾಡದೆಯೇ ಗ್ರೂಪ್ ಮಾಡಬೇಕಾದರೆ (ಉದಾ. ಒಂದು ಗುಂಪಿಗೆ ಕ್ವಾಂಟಿಫೈಯರ್ ಅನ್ನು ಅನ್ವಯಿಸಲು), ನೀವು (?:...) ಸಿಂಟ್ಯಾಕ್ಸ್‌ನೊಂದಿಗೆ ನಾನ್-ಕ್ಯಾಪ್ಚರಿಂಗ್ ಗ್ರೂಪ್ ಅನ್ನು ಬಳಸಬಹುದು. ಇದು ಕ್ಯಾಪ್ಚರ್ ಮಾಡಲಾದ ಗ್ರೂಪ್‌ಗಳಿಗೆ ಅನಗತ್ಯ ಮೆಮೊರಿ ಹಂಚಿಕೆಯನ್ನು ತಪ್ಪಿಸುತ್ತದೆ.
const regex = /(?:https?:\/\/)?([\w\.]+)/; // URL ಅನ್ನು ಹೊಂದಿಸುತ್ತದೆ ಆದರೆ ಡೊಮೇನ್ ಹೆಸರನ್ನು ಮಾತ್ರ ಕ್ಯಾಪ್ಚರ್ ಮಾಡುತ್ತದೆ
const url = "https://www.example.com/path";
const match = regex.exec(url);
console.log(match[1]); // ಔಟ್‌ಪುಟ್: www.example.com
ಲುಕ್ಅರೌಂಡ್ಸ್:
ಲುಕ್ಅರೌಂಡ್‌ಗಳು ಶೂನ್ಯ-ಅಗಲದ ಅಸರ್ಶನ್‌ಗಳಾಗಿವೆ, ಇವು ಸ್ಟ್ರಿಂಗ್‌ನಲ್ಲಿ ಒಂದು ಸ್ಥಾನವನ್ನು, ಆ ಸ್ಥಾನದ ಮೊದಲು (lookbehind) ಅಥವಾ ನಂತರ (lookahead) ಬರುವ ಪ್ಯಾಟರ್ನ್ ಆಧಾರದ ಮೇಲೆ ಹೊಂದಿಸುತ್ತವೆ, ಆದರೆ ಲುಕ್ಅರೌಂಡ್ ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಹೊಂದಾಣಿಕೆಯಲ್ಲಿ ಸೇರಿಸುವುದಿಲ್ಲ.
- ಪಾಸಿಟಿವ್ ಲುಕ್ಅಹೆಡ್:
(?=...)ಲುಕ್ಅಹೆಡ್‌ನೊಳಗಿನ ಪ್ಯಾಟರ್ನ್ ಪ್ರಸ್ತುತ ಸ್ಥಾನದ *ನಂತರ* ಬಂದರೆ ಹೊಂದಿಸುತ್ತದೆ. - ನೆಗೆಟಿವ್ ಲುಕ್ಅಹೆಡ್:
(?!...)ಲುಕ್ಅಹೆಡ್‌ನೊಳಗಿನ ಪ್ಯಾಟರ್ನ್ ಪ್ರಸ್ತುತ ಸ್ಥಾನದ *ನಂತರ* ಬರದಿದ್ದರೆ ಹೊಂದಿಸುತ್ತದೆ. - ಪಾಸಿಟಿವ್ ಲುಕ್‌ಬೆಹೈಂಡ್:
(?<=...)ಲುಕ್‌ಬೆಹೈಂಡ್‌ನೊಳಗಿನ ಪ್ಯಾಟರ್ನ್ ಪ್ರಸ್ತುತ ಸ್ಥಾನದ *ಮೊದಲು* ಬಂದರೆ ಹೊಂದಿಸುತ್ತದೆ. - ನೆಗೆಟಿವ್ ಲುಕ್‌ಬೆಹೈಂಡ್:
(? ಲುಕ್‌ಬೆಹೈಂಡ್‌ನೊಳಗಿನ ಪ್ಯಾಟರ್ನ್ ಪ್ರಸ್ತುತ ಸ್ಥಾನದ *ಮೊದಲು* ಬರದಿದ್ದರೆ ಹೊಂದಿಸುತ್ತದೆ.
ಉದಾಹರಣೆ:
// ಪಾಸಿಟಿವ್ ಲುಕ್ಅಹೆಡ್: USD ಅನುಸರಿಸಿದಾಗ ಮಾತ್ರ ಬೆಲೆಯನ್ನು ಪಡೆಯಿರಿ
const regex = /\d+(?= USD)/;
const text = "The price is 100 USD";
const match = text.match(regex);
console.log(match); // ಔಟ್‌ಪುಟ್: ["100"]
// ನೆಗೆಟಿವ್ ಲುಕ್ಅಹೆಡ್: ಸಂಖ್ಯೆಯು ಅನುಸರಿಸದಿದ್ದಾಗ ಮಾತ್ರ ಪದವನ್ನು ಪಡೆಯಿರಿ
const regex2 = /\b\w+\b(?! \d)/;
const text2 = "apple 123 banana orange 456";
const matches = text2.match(regex2);
console.log(matches); // ಔಟ್‌ಪುಟ್: null ಏಕೆಂದರೆ match() 'g' ಫ್ಲಾಗ್ ಇಲ್ಲದೆ ಮೊದಲ ಹೊಂದಾಣಿಕೆಯನ್ನು ಮಾತ್ರ ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಅದು ನಮಗೆ ಬೇಕಾಗಿಲ್ಲ.
// ಸರಿಪಡಿಸಲು:
const regex3 = /\b\w+\b(?! \d)/g;
const text3 = "apple 123 banana orange 456";
const matches3 = text3.match(regex3);
console.log(matches3); // ಔಟ್‌ಪುಟ್: [ 'banana' ]
// ಪಾಸಿಟಿವ್ ಲುಕ್‌ಬೆಹೈಂಡ್: $ ಚಿಹ್ನೆ предшеಿಸಿದಾಗ ಮಾತ್ರ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಿರಿ
const regex4 = /(?<=\$)\d+/;
const text4 = "The price is $200";
const match4 = text4.match(regex4);
console.log(match4); // ಔಟ್‌ಪುಟ್: ["200"]
// ನೆಗೆಟಿವ್ ಲುಕ್‌ಬೆಹೈಂಡ್: 'not' ಪದವು предшеಿಸದಿದ್ದಾಗ ಮಾತ್ರ ಪದವನ್ನು ಪಡೆಯಿರಿ
const regex5 = /(?
ಬ್ಯಾಕ್‌ರೆಫರೆನ್ಸಸ್:
ಬ್ಯಾಕ್‌ರೆಫರೆನ್ಸ್‌ಗಳು ಒಂದೇ ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ನೊಳಗೆ ಈ ಹಿಂದೆ ಕ್ಯಾಪ್ಚರ್ ಮಾಡಿದ ಗ್ರೂಪ್‌ಗಳನ್ನು ಉಲ್ಲೇಖಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತವೆ. ಅವು \1, \2, ಇತ್ಯಾದಿ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸುತ್ತವೆ, ಇಲ್ಲಿ ಸಂಖ್ಯೆಯು ಕ್ಯಾಪ್ಚರ್ ಮಾಡಿದ ಗ್ರೂಪ್ ಸಂಖ್ಯೆಗೆ ಅನುರೂಪವಾಗಿದೆ.
const regex = /([a-z]+) \1/;
const text = "hello hello world";
const match = regex.exec(text);
console.log(match); // ಔಟ್‌ಪುಟ್: ["hello hello", "hello", index: 0, input: "hello hello world", groups: undefined]
ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳ ಪ್ರಾಯೋಗಿಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು
ಇಮೇಲ್ ವಿಳಾಸಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸುವುದು:
ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳ ಸಾಮಾನ್ಯ ಬಳಕೆಯು ಇಮೇಲ್ ವಿಳಾಸಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸುವುದಾಗಿದೆ. ಪರಿಪೂರ್ಣ ಇಮೇಲ್ ಮೌಲ್ಯೀಕರಣ ರೆಜೆಕ್ಸ್ ಅತ್ಯಂತ ಸಂಕೀರ್ಣವಾಗಿದ್ದರೂ, ಇಲ್ಲೊಂದು ಸರಳೀಕೃತ ಉದಾಹರಣೆ ಇದೆ:
const emailRegex = /^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/;
console.log(emailRegex.test("test@example.com")); // ಔಟ್‌ಪುಟ್: true
console.log(emailRegex.test("invalid-email")); // ಔಟ್‌ಪುಟ್: false
console.log(emailRegex.test("test@sub.example.co.uk")); // ಔಟ್‌ಪುಟ್: true
ಟೆಕ್ಸ್ಟ್‌ನಿಂದ URLಗಳನ್ನು ಹೊರತೆಗೆಯುವುದು:
ಒಂದು ಟೆಕ್ಸ್ಟ್ ಬ್ಲಾಕ್‌ನಿಂದ URLಗಳನ್ನು ಹೊರತೆಗೆಯಲು ನೀವು ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳನ್ನು ಬಳಸಬಹುದು:
const urlRegex = /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&//=]*)/g;
const text = "Visit our website at https://www.example.com or check out http://blog.example.org.";
const urls = text.match(urlRegex);
console.log(urls); // ಔಟ್‌ಪುಟ್: ["https://www.example.com", "http://blog.example.org"]
CSV ಡೇಟಾವನ್ನು ಪಾರ್ಸ್ ಮಾಡುವುದು:
CSV (ಕಾಮ-ಸೆಪರೇಟೆಡ್ ವ್ಯಾಲ್ಯೂಸ್) ಡೇಟಾವನ್ನು ಪಾರ್ಸ್ ಮಾಡಲು ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳನ್ನು ಬಳಸಬಹುದು. ಇಲ್ಲಿ ಉಲ್ಲೇಖಿಸಲಾದ ಫೀಲ್ಡ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಮೂಲಕ CSV ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಮೌಲ್ಯಗಳ ಅರೇ ಆಗಿ ವಿಭಜಿಸುವ ಉದಾಹರಣೆ ಇದೆ:
const csvString = 'John,Doe,"123, Main St",New York';
const csvRegex = /(?:"([^"]*(?:""[^"]*)*)")|([^,]+)/g; //ಸರಿಪಡಿಸಿದ CSV ರೆಜೆಕ್ಸ್
let values = [];
let match;
while (match = csvRegex.exec(csvString)) {
values.push(match[1] ? match[1].replace(/""/g, '"') : match[2]);
}
console.log(values); // ಔಟ್‌ಪುಟ್: ["John", "Doe", "123, Main St", "New York"]
ಅಂತರರಾಷ್ಟ್ರೀಯ ಫೋನ್ ಸಂಖ್ಯೆ ಮೌಲ್ಯೀಕರಣ
ವಿವಿಧ ಫಾರ್ಮ್ಯಾಟ್‌ಗಳು ಮತ್ತು ಉದ್ದಗಳಿಂದಾಗಿ ಅಂತರರಾಷ್ಟ್ರೀಯ ಫೋನ್ ಸಂಖ್ಯೆಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸುವುದು ಸಂಕೀರ್ಣವಾಗಿದೆ. ಒಂದು ದೃಢವಾದ ಪರಿಹಾರವು ಸಾಮಾನ್ಯವಾಗಿ ಲೈಬ್ರರಿಯನ್ನು ಬಳಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಆದರೆ ಸರಳೀಕೃತ ರೆಜೆಕ್ಸ್ ಮೂಲಭೂತ ಮೌಲ್ಯೀಕರಣವನ್ನು ಒದಗಿಸಬಹುದು:
const phoneRegex = /^\+(?:[0-9] ?){6,14}[0-9]$/;
console.log(phoneRegex.test("+1 555 123 4567")); // ಔಟ್‌ಪುಟ್: true (US ಉದಾಹರಣೆ)
console.log(phoneRegex.test("+44 20 7946 0500")); // ಔಟ್‌ಪುಟ್: true (UK ಉದಾಹರಣೆ)
console.log(phoneRegex.test("+81 3 3224 5000")); // ಔಟ್‌ಪುಟ್: true (ಜಪಾನ್ ಉದಾಹರಣೆ)
console.log(phoneRegex.test("123-456-7890")); // ಔಟ್‌ಪುಟ್: false
ಪಾಸ್ವರ್ಡ್ ಸಾಮರ್ಥ್ಯ ಮೌಲ್ಯೀಕರಣ
ಪಾಸ್ವರ್ಡ್ ಸಾಮರ್ಥ್ಯದ ನೀತಿಗಳನ್ನು ಜಾರಿಗೊಳಿಸಲು ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳು ಉಪಯುಕ್ತವಾಗಿವೆ. ಕೆಳಗಿನ ಉದಾಹರಣೆಯು ಕನಿಷ್ಠ ಉದ್ದ, ದೊಡ್ಡಕ್ಷರ, ಸಣ್ಣಕ್ಷರ ಮತ್ತು ಸಂಖ್ಯೆಯನ್ನು ಪರಿಶೀಲಿಸುತ್ತದೆ.
const passwordRegex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$/;
console.log(passwordRegex.test("P@ssword123")); // ಔಟ್‌ಪುಟ್: true
console.log(passwordRegex.test("password")); // ಔಟ್‌ಪುಟ್: false (ದೊಡ್ಡಕ್ಷರ ಅಥವಾ ಸಂಖ್ಯೆ ಇಲ್ಲ)
console.log(passwordRegex.test("Password")); // ಔಟ್‌ಪುಟ್: false (ಸಂಖ್ಯೆ ಇಲ್ಲ)
console.log(passwordRegex.test("Pass123")); // ಔಟ್‌ಪುಟ್: false (ಸಣ್ಣಕ್ಷರ ಇಲ್ಲ)
console.log(passwordRegex.test("P@ss1")); // ಔಟ್‌ಪುಟ್: false (8 ಅಕ್ಷರಗಳಿಗಿಂತ ಕಡಿಮೆ)
ರೆಜೆಕ್ಸ್ ಆಪ್ಟಿಮೈಸೇಶನ್ ತಂತ್ರಗಳು
ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳು ಗಣನಾತ್ಮಕವಾಗಿ ದುಬಾರಿಯಾಗಬಹುದು, ವಿಶೇಷವಾಗಿ ಸಂಕೀರ್ಣ ಪ್ಯಾಟರ್ನ್‌ಗಳು ಅಥವಾ ದೊಡ್ಡ ಇನ್‌ಪುಟ್‌ಗಳಿಗೆ. ರೆಜೆಕ್ಸ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಉತ್ತಮಗೊಳಿಸಲು ಕೆಲವು ತಂತ್ರಗಳು ಇಲ್ಲಿವೆ:
- ನಿರ್ದಿಷ್ಟವಾಗಿರಿ: ಉದ್ದೇಶಕ್ಕಿಂತ ಹೆಚ್ಚು ಹೊಂದಿಕೆಯಾಗಬಹುದಾದ ಅತಿಯಾದ ಸಾಮಾನ್ಯ ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು ಬಳಸುವುದನ್ನು ತಪ್ಪಿಸಿ.
- ಆಂಕರ್‌ಗಳನ್ನು ಬಳಸಿ: ಸಾಧ್ಯವಾದಾಗಲೆಲ್ಲಾ ರೆಜೆಕ್ಸ್ ಅನ್ನು ಸ್ಟ್ರಿಂಗ್‌ನ ಆರಂಭಕ್ಕೆ ಅಥವಾ ಅಂತ್ಯಕ್ಕೆ ಆಂಕರ್ ಮಾಡಿ (
^,$). - ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕಿಂಗ್ ಅನ್ನು ತಪ್ಪಿಸಿ: ಸೂಕ್ತವಾದಾಗ ಪೊಸೆಸಿವ್ ಕ್ವಾಂಟಿಫೈಯರ್‌ಗಳನ್ನು (ಉದಾ.,
+ಬದಲಿಗೆ++) ಅಥವಾ ಅಟಾಮಿಕ್ ಗ್ರೂಪ್‌ಗಳನ್ನು ((?>...)) ಬಳಸುವ ಮೂಲಕ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕಿಂಗ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡಿ. - ಒಮ್ಮೆ ಕಂಪೈಲ್ ಮಾಡಿ: ನೀವು ಒಂದೇ ರೆಜೆಕ್ಸ್ ಅನ್ನು ಅನೇಕ ಬಾರಿ ಬಳಸಿದರೆ, ಅದನ್ನು ಒಮ್ಮೆ ಕಂಪೈಲ್ ಮಾಡಿ ಮತ್ತು
RegExpಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಮರುಬಳಕೆ ಮಾಡಿ. - ಕ್ಯಾರೆಕ್ಟರ್ ಕ್ಲಾಸಸ್‌ಗಳನ್ನು ಜಾಣತನದಿಂದ ಬಳಸಿ: ಕ್ಯಾರೆಕ್ಟರ್ ಕ್ಲಾಸಸ್‌ಗಳು (
[]) ಸಾಮಾನ್ಯವಾಗಿ ಆಲ್ಟರ್ನೇಶನ್‌ಗಳಿಗಿಂತ (|) ವೇಗವಾಗಿರುತ್ತವೆ. - ಸರಳವಾಗಿಡಿ: ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಕಷ್ಟಕರವಾದ ಅತಿಯಾದ ಸಂಕೀರ್ಣ ರೆಜೆಕ್ಸ್‌ಗಳನ್ನು ತಪ್ಪಿಸಿ. ಕೆಲವೊಮ್ಮೆ, ಸಂಕೀರ್ಣ ಕಾರ್ಯವನ್ನು ಅನೇಕ ಸರಳ ರೆಜೆಕ್ಸ್‌ಗಳಾಗಿ ವಿಭಜಿಸುವುದು ಅಥವಾ ಇತರ ಸ್ಟ್ರಿಂಗ್ ಮ್ಯಾನಿಪುಲೇಷನ್ ತಂತ್ರಗಳನ್ನು ಬಳಸುವುದು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿರುತ್ತದೆ.
ಸಾಮಾನ್ಯ ರೆಜೆಕ್ಸ್ ತಪ್ಪುಗಳು
- ಮೆಟಾಕ್ಯಾರೆಕ್ಟರ್‌ಗಳನ್ನು ಎಸ್ಕೇಪ್ ಮಾಡಲು ಮರೆಯುವುದು: ವಿಶೇಷ ಅಕ್ಷರಗಳಾದ
.,*,+,?,$,^,(,),[,],{,},|, ಮತ್ತು\ಅನ್ನು ಅಕ್ಷರಶಃ ಹೊಂದಿಸಲು ಬಯಸಿದಾಗ ಅವುಗಳನ್ನು ಎಸ್ಕೇಪ್ ಮಾಡಲು ವಿಫಲವಾಗುವುದು. .(ಡಾಟ್) ಅನ್ನು ಅತಿಯಾಗಿ ಬಳಸುವುದು: ಡಾಟ್ ಯಾವುದೇ ಅಕ್ಷರವನ್ನು ಹೊಂದಿಸುತ್ತದೆ (ಕೆಲವು ಮೋಡ್‌ಗಳಲ್ಲಿ ನ್ಯೂಲೈನ್ ಹೊರತುಪಡಿಸಿ), ಇದನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಬಳಸದಿದ್ದರೆ ಅನಿರೀಕ್ಷಿತ ಹೊಂದಾಣಿಕೆಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. ಸಾಧ್ಯವಾದಾಗ ಕ್ಯಾರೆಕ್ಟರ್ ಕ್ಲಾಸಸ್‌ಗಳು ಅಥವಾ ಇತರ ಹೆಚ್ಚು ನಿರ್ಬಂಧಿತ ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು ಬಳಸಿ ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟವಾಗಿರಿ.- ಗ್ರೀಡಿನೆಸ್ (ದುರಾಸೆ): ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ,
*ಮತ್ತು+ನಂತಹ ಕ್ವಾಂಟಿಫೈಯರ್‌ಗಳು ಗ್ರೀಡಿಯಾಗಿರುತ್ತವೆ ಮತ್ತು ಸಾಧ್ಯವಾದಷ್ಟು ಹೊಂದಾಣಿಕೆ ಮಾಡುತ್ತವೆ. ನೀವು ಸಾಧ್ಯವಾದಷ್ಟು ಚಿಕ್ಕ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹೊಂದಿಸಬೇಕಾದಾಗ ಲೇಜಿ ಕ್ವಾಂಟಿಫೈಯರ್‌ಗಳನ್ನು (*?,+?) ಬಳಸಿ. - ಆಂಕರ್‌ಗಳನ್ನು ತಪ್ಪಾಗಿ ಬಳಸುವುದು:
^(ಸ್ಟ್ರಿಂಗ್/ಲೈನ್‌ನ ಆರಂಭ) ಮತ್ತು$(ಸ್ಟ್ರಿಂಗ್/ಲೈನ್‌ನ ಅಂತ್ಯ) ನಡವಳಿಕೆಯನ್ನು ತಪ್ಪಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ತಪ್ಪಾದ ಹೊಂದಾಣಿಕೆಗೆ ಕಾರಣವಾಗಬಹುದು. ಮಲ್ಟಿಲೈನ್ ಸ್ಟ್ರಿಂಗ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಮತ್ತು^ಹಾಗೂ$ಪ್ರತಿ ಸಾಲಿನ ಆರಂಭ ಮತ್ತು ಅಂತ್ಯವನ್ನು ಹೊಂದಿಸಬೇಕಾದಾಗm(ಮಲ್ಟಿಲೈನ್) ಫ್ಲಾಗ್ ಅನ್ನು ಬಳಸಲು ಮರೆಯದಿರಿ. - ಎಡ್ಜ್ ಕೇಸ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸದಿರುವುದು: ಎಲ್ಲಾ ಸಂಭಾವ್ಯ ಇನ್‌ಪುಟ್ ಸನ್ನಿವೇಶಗಳು ಮತ್ತು ಎಡ್ಜ್ ಕೇಸ್‌ಗಳನ್ನು ಪರಿಗಣಿಸಲು ವಿಫಲವಾದರೆ ದೋಷಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. ನಿಮ್ಮ ರೆಜೆಕ್ಸ್‌ಗಳನ್ನು ಖಾಲಿ ಸ್ಟ್ರಿಂಗ್‌ಗಳು, ಅಮಾನ್ಯ ಅಕ್ಷರಗಳು ಮತ್ತು ಗಡಿ ಪರಿಸ್ಥಿತಿಗಳು ಸೇರಿದಂತೆ ವಿವಿಧ ಇನ್‌ಪುಟ್‌ಗಳೊಂದಿಗೆ ಸಂಪೂರ್ಣವಾಗಿ ಪರೀಕ್ಷಿಸಿ.
- ಕಾರ್ಯಕ್ಷಮತೆಯ ಸಮಸ್ಯೆಗಳು: ಅತಿಯಾದ ಸಂಕೀರ್ಣ ಮತ್ತು ಅಸಮರ್ಥ ರೆಜೆಕ್ಸ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವುದು ಕಾರ್ಯಕ್ಷಮತೆಯ ಸಮಸ್ಯೆಗಳನ್ನು ಉಂಟುಮಾಡಬಹುದು, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಇನ್‌ಪುಟ್‌ಗಳೊಂದಿಗೆ. ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟ ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು ಬಳಸುವ ಮೂಲಕ, ಅನಗತ್ಯ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕಿಂಗ್ ಅನ್ನು ತಪ್ಪಿಸುವ ಮೂಲಕ ಮತ್ತು ಪದೇ ಪದೇ ಬಳಸಲಾಗುವ ರೆಜೆಕ್ಸ್‌ಗಳನ್ನು ಕಂಪೈಲ್ ಮಾಡುವ ಮೂಲಕ ನಿಮ್ಮ ರೆಜೆಕ್ಸ್‌ಗಳನ್ನು ಉತ್ತಮಗೊಳಿಸಿ.
- ಕ್ಯಾರೆಕ್ಟರ್ ಎನ್‌ಕೋಡಿಂಗ್ ಅನ್ನು ನಿರ್ಲಕ್ಷಿಸುವುದು: ಕ್ಯಾರೆಕ್ಟರ್ ಎನ್‌ಕೋಡಿಂಗ್‌ಗಳನ್ನು (ವಿಶೇಷವಾಗಿ ಯೂನಿಕೋಡ್) ಸರಿಯಾಗಿ ನಿರ್ವಹಿಸದಿರುವುದು ಅನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. ಸರಿಯಾದ ಹೊಂದಾಣಿಕೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಯೂನಿಕೋಡ್ ಅಕ್ಷರಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ
uಫ್ಲಾಗ್ ಅನ್ನು ಬಳಸಿ.
ತೀರ್ಮಾನ
ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಪ್ಯಾಟರ್ನ್ ಮ್ಯಾಚಿಂಗ್ ಮತ್ತು ಟೆಕ್ಸ್ಟ್ ಮ್ಯಾನಿಪುಲೇಷನ್‌ಗಾಗಿ ಒಂದು ಮೌಲ್ಯಯುತ ಸಾಧನವಾಗಿದೆ. ರೆಜೆಕ್ಸ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಮತ್ತು ತಂತ್ರಗಳನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳುವುದು ಡೇಟಾ ಮೌಲ್ಯೀಕರಣದಿಂದ ಹಿಡಿದು ಸಂಕೀರ್ಣ ಟೆಕ್ಸ್ಟ್ ಪ್ರೊಸೆಸಿಂಗ್‌ವರೆಗೆ ವ್ಯಾಪಕ ಶ್ರೇಣಿಯ ಸಮಸ್ಯೆಗಳನ್ನು ಸಮರ್ಥವಾಗಿ ಪರಿಹರಿಸಲು ನಿಮಗೆ ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಈ ಮಾರ್ಗದರ್ಶಿಯಲ್ಲಿ ಚರ್ಚಿಸಲಾದ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ ಮತ್ತು ನೈಜ-ಪ್ರಪಂಚದ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ಅಭ್ಯಾಸ ಮಾಡುವ ಮೂಲಕ, ನಿಮ್ಮ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿ ಕೌಶಲ್ಯಗಳನ್ನು ಹೆಚ್ಚಿಸಲು ನೀವು ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳನ್ನು ಬಳಸುವುದರಲ್ಲಿ ಪ್ರವೀಣರಾಗಬಹುದು.
ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳು ಸಂಕೀರ್ಣವಾಗಿರಬಹುದು ಎಂಬುದನ್ನು ನೆನಪಿಡಿ, ಮತ್ತು ಅವುಗಳನ್ನು regex101.com ಅಥವಾ regexr.com ನಂತಹ ಆನ್‌ಲೈನ್ ರೆಜೆಕ್ಸ್ ಪರೀಕ್ಷಕಗಳನ್ನು ಬಳಸಿ ಸಂಪೂರ್ಣವಾಗಿ ಪರೀಕ್ಷಿಸುವುದು ಸಾಮಾನ್ಯವಾಗಿ ಸಹಾಯಕವಾಗಿದೆ. ಇದು ಹೊಂದಾಣಿಕೆಗಳನ್ನು ದೃಶ್ಯೀಕರಿಸಲು ಮತ್ತು ಯಾವುದೇ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಡೀಬಗ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಹ್ಯಾಪಿ ಕೋಡಿಂಗ್!