Regular Expressions

^ back on top ^

^ back on top ^

• Bracket Expressions(POSIX Bracket Expressions)
  Bracket Expressions are supported by the shell itself. However, it is important to note that in regular expressions, the ordering of characters within bracket expressions is not affected by the environment or locale, which is different from the use of wildcards in the shell.The most notable feature of bracket expressions is that the rules to be matched are enclosed in square brackets "[ ]", and regardless of how complex the content inside is, it represents only a single character that matches the pattern. Common usages are as follows:
  
  
  • [One or more characters] : Matches a single character
    The square brackets "[ ]" indicate that any character placed inside will match any one of those characters.For example, "[xyz]" means it can match either the character "x" or "y" or "z", but not the string "xyz".
    
    (vi editor)
    

    busy buzzing bumblebees buzzing busying 6 silly sisters selling shining shoes The driver was drunk and drove the doctor's car into deep ditch. (The middle output portion is omitted) /bu[nms] ←"In the vi status line, search for a string following 'bu' that is followed by either 'n', 'm', or 's'.

    
    "If the matched text is not highlighted during the experiment in vi ,please set ':set hlsearch' in the vi environment configuration to enable highlighting of matched text. (Note that highlighting is supported only in vim, and most distributions have replaced vi with vim.)
    
    
  • [Start character - end character]: Specify the range of characters to match
    If you want to match a character in a certain range, the range must be from small to large, with a "-" interval between the ranges, and there must be no space between the character and "-".
    
    For example, "[xz]" means that the character "x" or "y" or "z" can be matched, which is equivalent to "[xyz]".
    Among them, "-" has a particularly high combination rate for the characters on the left and right sides. For example, "[ab -z ]" does not match the characters "a", "b", "-" or "z". But "a" or "b~z", so the result is equal to "[a-z]", and the same function can also be written as "[abc-ijkl-z]" if happy.
    
    Commonly used usage is as follows:
    

    Regular Expressions	Matches
    [0-9]	any number
    [a-z]	all lowercase letters
    [A-Z]	all uppercase letters
    [a-zA-Z] 或 [A-Za-z]	all letters
    [0-9a-zA-Z]	any numbers and letters

    
    Do not use ambiguous expressions such as "[a-Z]", "[0-z]", "[A-9]" or "[0-/]" because the size sorting is not based on ASCII size, different different tools can produce different results.
    
    Some writing looks weird but is legal, such as "[6-9-]" or "[-6-9]" means matching "6~9" and "-".
    And "[6-9-z]" means match "6~9" or "-" or "z". When you can't see it for a while, match the combination rate from left to right, but it can't be combined again if it has been combined. For example, "[6-9-z]" should be regarded as [6-9 -z]" (the green background is Combine with the characters around "-"), and then use the combination rate to check the rest. If it can't be combined again, it means that the respective characters are not in the range. Example
    
    
    (vi editor)
    

    busy buzzing bumblebees buzzing busying 6 silly sisters selling shining shoes The driver was drunk and drove the doctor's car into deep ditch. can you can a can as a canner can can a can google Goggles Solves SUDOKU Puzzles. How much oil boil can a gum boil boil if a gum boil can boil oil? Where's the peck of pickled peppers Peter Piper picked? (The middle output portion is omitted) /[A-Z]he ←Search for a string where the first letter is capitalized and followed by 'he'.

    
    
    
  • [^ ]: Reverse matching
    In order to ireverse matching the range to be matched, for example, "[^xyz]" matches any character except "x" or "y" or "z".
    
    Reverse matching can also work with "[Start character-End character]", such as "[^A-Z]" means match except capital letters.
    
    The reverse matching "^" must be written in the first position of "[ ]" to be an inversely filter. For example, "[0-9^AZ]" is reverse matching , but it can match any number, capital letter and The symbol "^".
    Therefore, "[^^0-9]" or "[^0-9^]" means that all matches except the numbers 0-9 and the symbol "^".
    
    (vi editor)
    

    busy buzzing bumblebees buzzing busying 6 silly sisters selling shining shoes The driver was drunk and drove the doctor's car into deep ditch. can you can a can as a canner can can a can (The middle output portion is omitted) /[^A-Z]he ←search 1st word The element is not capitalized, followed by a string of "he"

    
    
    

  ^ back on top ^

• POSIX Characters
  POSIX Characters also exists in wild characters. The biggest advantage of using wild characters is that the output results will not be affected by different locales settings. It can simplify the description when used in regular expressions .
  For example, to match all punctuation and symbols, it may be written as "[^0-9a-zA-Z ]", which still does not take into account the writing of characters that are not displayed (Whitespace), such as using POSIX-character as long as "[ :punct:]" Simple yet powerful.
  
  The actual application of POSIX-characters requires multiple square brackets such as "[[:punct:]]", because the outermost "[ ]" represents the range of Bracket Expressions, and the inner "[::]" is meta-character.
  Because POSIX character is a subset of bracket expressions, it can be combined with various square bracket expressions introduced above, such as "[[:upper:]xyz]" or "[^[: upper:]0-9]", [^[:upper:][:lower:]]", etc.
  
  The meanings represented by each POSIX-character are as follows:
  

  POSIX Characters  matches characters
  POSIX	ASCII	Illustrate	Note
  [:alnum:]	[A-Z,a-z,0-9]	English alphabet and numbers
  [:alpha:]	[A-Z,a-z]	English alphabet
  [:blank:]		Space(ASCII = 20H)和 TAB(ASCII = 9H)
  [:cntrl:]	[0H-1FH,7FH]	Control character
  [:digit:]	[0-9]	Number
  [:graph:]	[21H-7EH]	Characters that will be displayed
  [:upper:]	[A-Z]	Uppercase letter
  [:lower:]	[a-z]	Lower case letters
  [:print:]	[20H-7EH]	Characters that will be displayed + spaces
  [:punct:]	[\]\[!"#$%&')(*+,./:;<=>?@\^_`{|}~-]	Punctuation and symbols
  [:space:]	[ \t\r\n\v\f]	Whitespace(characters not displayed)	Whitespace characters (such as newlines ) are generally not displayed, but Linux has its fixed representations for some commonly used Whitspace characters (refer to the column "Linux Common Representations" in [note] ASCII)
  [:xdigit:]	[A-F,a-f,0-9]	Character in hexadecimal

  
  
  (vi editor)

  busy buzzing bumblebees buzzing busying 6 silly sisters selling shining shoes The driver was drunk and drove the doctor's car into deep ditch. can you can a can as a canner can can a can google Goggles Solves SUDOKU Puzzles. How much oil boil can a gum boil boil if a gum boil can boil oil? Where's the peck of pickled peppers Peter Piper picked? 55 Flags freely flutter from the floating frigate (The middle output portion is omitted) /[[:digit:]] ← Search for Arabic numerals with POSIX Character

  
  
• . : Match any single character
  A "." can match any single character (must exist), somewhat similar to "?" of wildcards .
  
  "." Represents any existing characters, such as "x.y" means that it can match "xay", "xBy" or "xxy", etc. but cannot match "xy".
  This is an independent subset and cannot be mixed with the square bracket expressions . For example, "[x.y]" means that it can match the character "x" or "." .
  
  "." must be written outside the square brackets to represent its meaning. For example, "[A-Z]. " means that the first character can be matched as a capital letter, and the second character can be used casually.
  And "[A.Z]" means that it can match most of "A" or "." or "Z"
  
  Linux and Unix-like, "." means any character (including symbols,invisiable characters) except newline elements and control characters).
  
  Example: ( vi operation)
  

  busy buzzing bumblebees buzzing busying 6 silly sisters selling shining shoes The driver was drunk and drove the doctor's car into deep ditch. (The middle output portion is omitted) /s.ll ←Because "." can match any character, so the "sill" or "sell" both match

  
  
  
• * : Characters before matching are repeated from zero to infinite
  The "*" is the same symbol as the wildcards, but their functionalities are quite different. In regular expressions, the "*" indicates zero or more occurrences of the preceding character(s).
  It is crucial to note which character is the "preceding" one. For example, in the pattern "x*z," the preceding character before the "*" is "x", so it means that "x" can appear 0 to infinite times. Therefore, it can match "z," "xz," "xxz," "xxxxxxxxxxz," and so on. So,
  
  Iif you want to express one or more consecutive uppercase letters (such as A or BB or ABCDEFG), you can write it as "[A-Z][0-9]*" or "[A-Z]g*" and similar patterns. However, it is more common to write it as "[A-Z][A-Z]*" to "imply" the intention, so that it is easier to understand and not end up with incomprehensible code. Similarly, to match any character, you can use ".*" to represent matching any "thing" (including nothing), which is more readable than writing "A*" or "3*" and so on.
  
  Here are some practical examples:

  Regular Expression	Matches	Example
  .*	Zero to any character.	[\]\[!"#$ABCabc0123\n\a\t etc.
  [0-9][0-9]*	One or more consecutive digits.	0、11、12345、 543543543
  [A-Z][A-Z]*	Greater than or equal to one or more consecutive uppercase letters.	Y、IJK、ZZZZZZ
  [a-z][a-z] *	Greater than or equal to one or more consecutive lowercase letters.	z、xyz、abcdefghijk
  Goo*gle	The "o" between G and gle can range from one to infinity	Gogle、Google、Gooooooooooogle
  yaho*	yah "o" can be zero to infinite	yah、yaho、yahoooooooooooooo
  .*k	from the first arbitrary character until "k" is encountered	This is a book
  G.*	"G" starts and continues until newline	Good morning Mr. Chen

  If you add the caret symbol "^" at the beginning of the pattern, it signifies that the pattern must be at the beginning of a line to be considered a match.
  
  例:(vi 操作)
  

  busy buzzing bumblebees buzzing busying 6 silly sisters selling shining shoes The driver was drunk and drove the doctor's car into deep ditch. can you can a can as a canner can can a can (The middle output portion is omitted) /can*

  
  In the above example, because the character "n"=0 in front of "*" also matches, "ca", "can" and "cann" or "cannnnnn" (infinitely repeating the adjacent previous characters) are all consistent.
  
  

  ^ back on top ^

• ^ : Match the string at the start position
  If you add "^" in front of the pattern, it means that the pattern must be at the beginning of a certain line to be considered a match.
  
  Example: ( vi operation)
  

  busy buzzing bumblebees buzzing busying 6 silly sisters selling shining shoes The driver was drunk and drove the doctor's car into deep ditch. can you can a can as a canner can can a can   (The middle output portion is omitted) /^can

  
  In the above example, there are many "can" character strings, but adding a "^" to the former not only requires the strings to match but also the starting position of the line to be considered a real match.
  In addition, do not confuse it with the reverse matching "[^ ]", The "[^ ]" is the reverse matching, and "^[ ]" denotes matching the starting position.
  
  Example: ( vi operation)
  

  busy buzzing bumblebees buzzing busying 6 silly sisters selling shining shoes The driver was drunk and drove the doctor's car into deep ditch. can you can a can as a canner can can a can google Goggles Solves SUDOKU Puzzles. (The middle output portion is omitted) /^[^A-Z] ← matches characters whose starting position is not uppercase

  
  
  
• $ : Match the string at the end position
  If you add "$^" after the pattern, it means that the pattern must be at the last position of a line to be considered a match.
  
  Example: ( vi operation)
  

  busy buzzing bumblebees buzzing busying 6 silly sisters selling shining shoes The driver was drunk and drove the doctor's car into deep ditch. can you can a can as a canner can can a can   (The middle output portion is omitted) /an$

  
  In the above example, because there are many "an" strings, adding "$^" at the end of the pattern not only must match the pattern, but also must be at the last position of the line to be considered a real match.
  Therefore, if "^" and "$" are combined and written as "^$", it means to match a blank line with nothing at the beginning and at the end (only newline and no other characters), and if it is "^hello$", it means to match a line with only a list" hello" nothing else.
  
  Example: ( vi operation)
  

  busy buzzing bumblebees buzzing busying 6 silly sisters selling shining shoes The driver was drunk and drove the doctor's car into deep ditch. can you can a can as a canner can can a can   ←blank line google Goggles Solves SUDOKU Puzzles.   (The middle output portion is omitted) /^$ ← matches a blank line

  
  
  
• &: Remember the matched string
  We can use "&" to represent the matched string. That is, "&" is a variable, at this time "&=matched string".
  For example, if the regular expressions "colou*r" matches the string "color", then &=color, if the matched string is "colour", then &=colour.
  
  Memory matching "&" is mainly used for replacement, (replace with the pattern represented by "&"), so please use the substitution of vi command mode to test in the following example.
  See the example below to make it clearer.
  
  Example: (Use the replacement of the vi command mode to test)
  

  busy buzzing bumblebees buzzing busying 6 silly sisters selling shining shoes (The) driver was drunk and drove the doctor's car into deep ditch. can you can a can as a canner can can a can google(Goggles)(Solves) SUDOKU (Puzzles). (The middle output portion is omitted) :1,$ s/[A-Z][a-z][a-z]*/(&)/g ←Add "( )" to the words whose first letter is uppercase and the subsequent letter is lowercase

  
  In the above example, the word matched for the first time is "The", so &=The, and when replaced with "(&)", the result is "(The)" because &=The; the word matched for the second time For "Goggles" and so on.
  (The above example uses the replacement operation of the vi command mode )
  
  

  ^ back on top ^

• {a,b} : Match the character before the repetition
  Because the "*" in the regular expression can only match the preceding characters from 0 to ∞, it is obviously insufficient. If you want to specify the number of preceding characters, use "{a,b" }", for example "o{2,4}" means it can match 2~4 consecutive "o".
  In the format of "{a,b}", a is the lower limit of the number of repetitions of the previous character, and b is the upper limit; if it is written as "{a}", it is a fixed number of repetitions of the previous character.
  
  Special attention should be paid to the basic regular expressions "{ }", "( )", "< >" and "|" in brackets are regarded as reserved symbols, so escape characters should be added and written as " \ { a,b\}".
  
  Example: ( vi operation)
  

  What are the numbers for I II III IV V VI VII VIII VIIII in Roman numerals?     (The middle output portion is omitted) /VI\{2,3\} ←Search for 2~3 consecutive "I" strings after "V"

  
  In addition, if one of the elements in "{a,b}" is omitted, it means that there is no upper limit or lower limit for the preceding repeated characters.
  
  Example: ( vi operation)
  

  gogle google gooogle goooogle gooooogle is a gd god good goood     (The middle output portion is omitted) /go\{,2\}d ← search for a string between "g" and "d" where the upper limit of "o" is 2

  
  Example: ( vi operation)
  

  gogle google gooogle goooogle gooooogle is a gd god good goood     (The middle output portion is omitted) /o\{3\} ←Search for strings where the lower limit of "o" is 3

  
  
• ( ): Set the string before the match
  The "*" or "{}" introduced above match the repeated "chracters" before the set match, but how to deal with the repeated "string" ? Such as the string "AwxywxywxywxyB", you can enclose the string with "( )" and treat it as characters. For example, "A(wxy)*B" can match "AwxyB" or "AwxywxywxyB".
  
  Some sets of "( )" are matched with "*" or "+" and "?" of extended regular notation , etc. can have the effect of empowerment and multiplication. The following are common usages:
  
  • 〝( )*〞 : Set matches from zero to infinity.
  • 〝( )+〞 : set matching from one to infinity (extended regular expression is only supported).
  • 〝( )?〞 : Set matches zero to one (extended regular notation is only supported).
  
  Example: ( vi operation)
  

  1,000 milliliter equal 1 liter. (The middle output portion is omitted) /\(li\)*ter ← Matches "li" from 0~∞ in front of "ter"

  
  

  ^ back on top ^

• < > : Match the single word
  Matching individual words is sometimes not as easy as you might imagine. For example, if you only want to find the word "oil," without proper spacing, you might also match words like "boil" or "unspoiled," which are not the intended matches. The simplest solution to avoid such headaches is to enclose the desired pattern you want to match with "< >" brackets.
  
  Example: ( vi operation)
  

  busy buzzing bumblebees buzzing busying 6 silly sisters selling shining shoes The driver was drunk and drove the doctor's car into deep ditch. can you can a can as a canner can can a can google Goggles Solves SUDOKU Puzzles.   (The middle output portion is omitted) /\<[[:upper:]]*\> ← matches words with uppercase letters

  
  Word matching can also be fun to explore. For example, we all know that every English word has a vowel, which can be A, E, I, or U (with the exception of the words "by" and "fly" as the only two words without vowels). I can use "<[^aeiouyAEIOUY]*>" to preliminarily find words without vowels and exclude possible misspellings.
  
  
• ( )\1 : Backward reference memory match
  " &  " can memorize only one matched character string, if you want to memorize more than one matched character string, you can use back-reference memory matching "( )\1 "."
  Among them, "( )" is the matching condition, and "\1" is the memory of the first matching variable, which can be changed from "( )( )( )( )( )( )( )( )( )\1 at most. \2\3\4\5\6\7\8\9〞A total of 9.
  For example, if "(abc)(def)(ghi) \1\2\3" is matched, then \1=abc, \2=def, \3=ghi.
  
  Where is Back-Referencememory matching used? Don’t look at the answers below. The tester uses regular expressions to match two adjacent and identical letter strings (such as "bb", "ee", "AA" in a word) ", "GG" and other strings).
  
  Maybe there is a way, but I can't think of it, but if you use Back-Referencememory matching to write "\([a-zA-Z]\)\1", it will do.
  
  Example: ( vi operation)
  

  busy buzzing bumblebees buzzing busying 6 silly sisters selling shining shoes>   (The middle output portion is omitted) /\([a-zA-Z]\)\1 ←Search for a string of two adjacent and identical letters

  
  In the above example, "[a-zA-Z]" will match any English character, so at the beginning, "[a-zA-Z]" matches the first character "b" at the beginning of the article. At this time, the variable "\ 1" is equal to the character "b", so it matches the string "bb", and so on "[a-zA-Z]" to match the next character "u" (at this time, the variable "\1" = "u )" so start to match the string "uu" and go on to find two adjacent strings with the same letter.
  
  Because "( )( )( )...\1\2\3...\9" can be up to 9, a more complicated example, such as "\([a-z]\)\([a-z]\)\ 2\1〞Swap the position of the variable and what can be matched, think about it or test it yourself.
  
  Backward reference memory matching is not only used for searching, but also commonly used for replacing, as in the following example.
  
  Example: (Use the replacement of the vi command mode to test)
  

  busy buzzing bumblebees buzzing busying silly 6 sisters selling shining shoes The driver was drunk and drove the doctor's car into deep ditch. (The middle output portion is omitted) :1,$ s/\(\<[0-9]*\>\) \(\<[a-z]*\>\) /\2 \1 /g ← If the matching string is all numbers and the next string is all lowercase letters, exchange positions

  
  In the above example, "(\<[0-9]*\>\)" matches the digital string "6", so "\1=6", "(\<[az]*\>\)" matches To the string "silly", so "\2=silly", and deliberately put "\2" before "\1" when replacing, so the purpose of swapping is achieved.
  

• | : Or match
  Or match "|" should be in the extended regular expressions , but modern Linux/UNIX-like is also included in the basic regular expressions, but in order to distinguish it, escape characters are added and written as "\|" . The base regular notation for missing or matching "|" seems to be limping around.
  
  Or matching is to perform "or" operation on the templates on the left and right sides of "|"; that is, one of the two sides of "|" matches. For example, "[1-3]\|xyz" means that the numbers 1~3 or the string "xyz" can be matched.
  
  Example: ( vi operation)
  

  busy buzzing bumblebees buzzing busying 6 silly sisters selling shining shoes The driver was drunk and drove the doctor's car into deep ditch. can you can a can as a canner can can a can google Goggles Solves SUDOKU Puzzles. (The middle output portion is omitted) /bus\|buzz ←matching "bus" or "buzz"

  
  In addition, you can enclose "|" with "( )" to narrow the matching range, for example, "iphone\(4s\|5\)" means that both "iphone4s" and "iphone5" are matched.
  
  
  

  ^ back on top ^

• Add "|" or match. (The original basic formal representation should be written as "\|").
• The original basic regular expression should be written as "\{ \}", and "\( \)" looks like an unsightly escaped character. Remove it.
• Add "+" and "?" to represent the characters (metacharacter).

• | : Or match
  Is the same function as the or match of the basic regular expressions but used in the extended regular expression without adding escape characters. Because vi does not support extended regular expressions, the following operations are replaced by grep .
  
  example:
  

  $ grep -E 'ca(r|n)' re.txt ← match "car" or "can" (note! No need to escape characters) The driver was drunk and drove the doctor's car into deep ditch. can you can a can as a canner can can a can How much oil boil can a gum boil boil if a gum boil can boil oil? $ grep 'ca\(r\|n\)' re.txt ←If the option "-E" is removed For the basic regular expressions, or-match to add escape characters

  
  
  
• + : Match the previous zero to one repeated characters
  which is equivalent to the usage of "{1,}" in the basic regular expressions . For example, "(xyz)+" can match "xyz" or "xyzxyz" or "xyzxyzxyz"
  
  Example:

  $ grep -E 'go+gle' re.txt ← list "gogle" or "google" or "goooooooooooogle" google Goggles Solves SUDOKU Puzzles $ seq 1 10000 | grep -E '^199+' ← list 199, 199, 19999999 Related figures 199 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999

  
  
  
• ? : Match zero to one repeated character in front of "?"
  It is equivalent to the usage of "{0,1}" in the basic regular expressions.
  
  例:

  $ grep -E '[+-]?[0-9]+\.[0-9]+([Ee][+-][0-9]+)?' fileA ←List the real numbers in "fileA"

^ back on top ^