Source From Here
LookArounds
Lookarounds let me to do more than just match a pattern directly. They let me to define a context for that match. An expression with a lookaround only returns a match when it is surrounded by a certain context. Let’s start with a new string, yet another Star Wars quote from Obiwan Kenobi.
I want to know all the places the word "fool" is used in this string. I’m going to use the regular expression /fool/. In this case, I’m going to use Ruby’s scan method on my string. The scan method will return all matches for my regular expression in my string:
Notice it matches the word "foolish" and the two uses of the word "fool."
What if I only want to match the pattern /fool/ when it is part of the word foolish? I would use a positive lookahead. This tells my regular expression engine to find every match for my pattern that is directly followed by a match for another pattern. In Ruby, we designate something as a positive lookahead by using ?= operator:
Here’s my modified regular expression. Notice I have the primary pattern, which is the literal world "fool," and directly to the right of it I have the lookahead pattern, the letters "ish":
This time, the scan method only returns one match – the one time the word "fool" is followed by the characters "ish". Let’s take this a step further and use the gsub method to change our string. Anytime we match the pattern fool –followed by the letters "ish", let’s replace it with the word "self":
Technically, this is referred to as a zero width, positive lookaround assertion. That’s a mouthful, isn’t it? In The Well Grounded Rubyist, David Black breaks it down like this:
What if I wanted to do something slightly different? What if I wanted to match every time the word fool is NOT followed by the letters "ish"? I would use a negative lookahead. Technically, this is referred to as a zero-width negative lookahead assertion. Negative means a match for our lookahead should NOT be present, we’re not expecting it to be there. You use the ?! operator to designate a negative lookahead.
I’m going to run scan on my string again, but this time with a negative lookahead in my regular expression. I want it to match every time the fool is NOT a part of the word foolish:
It returns two matches, the two times the string uses the word "fool" without being part of the word foolish. Let’s take it a step further and use it with the gsub method. Anytime the we match the pattern fool - only when it is NOT followed by the letters "ish" - let’s replace it with the word "self":
These examples are great when I want to find a match based on what comes after it. Again, let’s take it a step further. What if I want to find a match based on what comes before? I need to use a positive lookbehind assertion. This means I want to match a pattern every time it is directly preceded by another pattern.
Let’s use another Star Wars quote for our string, this one from Yoda:
The main pattern I want to match is the word ally using the regular expression /ally/. I only want to match the word "ally" when the word "powerful" comes directly before it, however. This is where the positive lookbehind comes in. Positive lookbehinds use the ?<= operator. Let’s add it to our regular expression:
This regular expression matches the word "ally" every time it is directly preceded by the word powerful. Notice the lookbehind is behind the main pattern. The lookbehind needs to come before the main match. The word "powerful" needs to come before the word "ally."
Now I’m going to use the gsub method on the string. Every time the word "ally" is directly preceded by the world powerful, I want to replace it with the word "friend":
What if I want to do the opposite? What if I want to match every time the word "ally" is NOT followed by the word "powerful?" I would use a negative lookbehind. This means I want to match my pattern every time it is NOT directly preceded by another pattern. Negative lookbehinds use the ?<! operator. Let’s apply it to the regular expression:
Let’s run gsub using this regular expression, replacing the word "ally" every time it is NOT directly preceded by the word "friend":
Lookarounds provide a tremendous boost to your regular expressions because they help you define context. Rather than being a static pattern that either matches or doesn’t, your regular expression becomes powerful, flexible, and capable of much more.
Supplement
* Using Regular Expression in Ruby - Part1
* Using Regular Expression in Ruby - Part3
This is a blog to track what I had learned and share knowledge with all who can take advantage of them
標籤
- [ 英文學習 ]
- [ 計算機概論 ]
- [ 深入雲計算 ]
- [ 雜七雜八 ]
- [ Algorithm in Java ]
- [ Data Structures with Java ]
- [ IR Class ]
- [ Java 文章收集 ]
- [ Java 代碼範本 ]
- [ Java 套件 ]
- [ JVM 應用 ]
- [ LFD Note ]
- [ MangoDB ]
- [ Math CC ]
- [ MongoDB ]
- [ MySQL 小學堂 ]
- [ Python 考題 ]
- [ Python 常見問題 ]
- [ Python 範例代碼 ]
- [心得扎記]
- [網路教學]
- [C 常見考題]
- [C 範例代碼]
- [C/C++ 範例代碼]
- [Intro Alg]
- [Java 代碼範本]
- [Java 套件]
- [Linux 小技巧]
- [Linux 小學堂]
- [Linux 命令]
- [ML In Action]
- [ML]
- [MLP]
- [Postgres]
- [Python 學習筆記]
- [Quick Python]
- [Software Engineering]
- [The python tutorial]
- 工具收集
- 設計模式
- 資料結構
- ActiveMQ In Action
- AI
- Algorithm
- Android
- Ansible
- AWS
- Big Data 研究
- C/C++
- C++
- CCDH
- CI/CD
- Coursera
- Database
- DB
- Design Pattern
- Device Driver Programming
- Docker
- Docker 工具
- Docker Practice
- Eclipse
- English Writing
- ExtJS 3.x
- FP
- Fraud Prevention
- FreeBSD
- GCC
- Git
- Git Pro
- GNU
- Golang
- Gradle
- Groovy
- Hadoop
- Hadoop. Hadoop Ecosystem
- Java
- Java Framework
- Java UI
- JavaIDE
- JavaScript
- Jenkins
- JFreeChart
- Kaggle
- Kali/Metasploit
- Keras
- KVM
- Learn Spark
- LeetCode
- Linux
- Lucene
- Math
- ML
- ML Udemy
- Mockito
- MPI
- Nachos
- Network
- NLP
- node js
- OO
- OpenCL
- OpenMP
- OSC
- OSGi
- Pandas
- Perl
- PostgreSQL
- Py DS
- Python
- Python 自製工具
- Python Std Library
- Python tools
- QEMU
- R
- Real Python
- RIA
- RTC
- Ruby
- Ruby Packages
- Scala
- ScalaIA
- SQLAlchemy
- TensorFlow
- Tools
- UML
- Unix
- Verilog
- Vmware
- Windows 技巧
- wxPython
訂閱:
張貼留言 (Atom)
[Git 常見問題] error: The following untracked working tree files would be overwritten by merge
Source From Here 方案1: // x -----删除忽略文件已经对 git 来说不识别的文件 // d -----删除未被添加到 git 的路径中的文件 // f -----强制运行 # git clean -d -fx 方案2: 今天在服务器上 gi...
-
前言 : 為什麼程序管理這麼重要呢?這是因為: * 首先,本章一開始就談到的,我們在操作系統時的各項工作其實都是經過某個 PID 來達成的 (包括你的 bash 環境), 因此,能不能進行某項工作,就與該程序的權限有關了。 * 再來,如果您的 Linux 系統是個...
-
屬性 : 系統相關 - 檔案與目錄 語法 : du [參數] [檔案] 參數 | 功能 -a | 顯示目錄中個別檔案的大小 -b | 以bytes為單位顯示 -c | 顯示個別檔案大小與總和 -D | 顯示符號鏈結的來源檔大小 -h | Hum...
-
來源自 這裡 說明 : split 是 Perl 中非常有用的函式之一,它可以將一個字串分割並將之置於陣列中。若無特別的指定,該函式亦使用 RE 與 $_ 變數 語法 : * split /PATTERN/,EXPR,LIMIT * split /...
沒有留言:
張貼留言