perlrequick -- Perl regular expression quickstart (2023)

• Name
• describe
• tourist guide
  • simple word pairing
  • Use character classes
  • fits this or that
  • Hierarchical clustering and matching
  • extract matches
  • double match
  • further placements
  • search and replace
  • division operator
  • use re "strict"
• flee
• See also
• Author and Copyright
  • gracias

perlrequick -- Perl regular expression quickstart

This page covers the basics of understanding, creating, and using regular expressions ("regexes") in Perl.

This page assumes you already know a few things, such as: B. what a "mode" is and the basic syntax for using it. If not, check it outperlretut.

#simple word pairing

The simplest regular expression is just a word, or more generally a string. A regular expression consisting of one word matches any string containing that word:

"Hello World" = ~/world/; # Matches

In this statementWeltis a regular expression and//Cerrado/Welt/Tells Perl to look for a match in the string. operator=~Concatenates a string with a regular expression match, returning true if the regular expression matches and false if the regular expression doesn't match. In our example,Weltsecond word in play"Hello World", so the expression is true. There are several variations on this idea.

Expressions like this are useful in conditional statements:

if „Hello World“ = ~/World/, imprime „coincide con \n“;

The meaning of a match can be reversed with!~Operator:

print „Mismatch\n“ if „Hello World“ !~ /World/;

String literals in regular expressions can be replaced with variables:

$greeting = "World";print "Match\n" if "Hello World" =~ /$greeting/;

If you agreePS, It is$_ =~Parts can be left out:

$_ = "Hallo Welt"; print „Match\n“ if /World/;

last but not least,//The default delimiter for the match can be changed by placing it in any delimiter'Metro'before:

"Hello World" =~ m!World!; # match separated by '!' "Hello World" =~ m{World}; # match, look for match '{}'"/usr/bin/perl" = ~ m "/perl"; # After matching "/usr/bin", "/" becomes an ordinary character

The regular expression must match part of the stringExactlyFor the statement to be true:

"Hello World" =~ /world/; # mismatch, case sensitive "Hello World" =~ /o W/; # matches ' ' is a normal character "Hello World" =~ /World /; # does not match, no end ''

Perl always looks for the earliest possible point in the string:

"Hello World" =~ /o/; # matches 'o' in 'hello' "This hat is red" =~ /hat/; # matches "hat" in "That".

Not all characters can be used in a game "as is". some characters, namedmetacharactersare considered special and reserved for regular expression notation. The metacharacters are

{}[]()^$.|*+?\

Metacharacters can be joined literally by preceding them with a backslash:

"2+2=4" =~ /2+2/; # does not match, + is a metacharacter "2+2=4" =~ /2\+2/; # matches, \+ is treated as a normal character + 'C:\WIN32' =~ /C:\\WIN/; # matches "/usr/bin/perl" =~ /\/usr\/bin\/perl/; # fit

The slash in the last regular expression'/'Also a backslash as it is used to delimit regular expressions.

Most metacharacters are not always special, other characters (e.g. pattern separators) become special under different circumstances. This can be confusing and produce unexpected results.use re "strict"It can inform you about possible dangers.

Non-printable ASCII characters are represented asescape sequenceA common example is\Tfor labels,\nortefor new lines and\RGot in. Arbitrary bytes are represented by octal escape sequences, for example:\033, or a hexadecimal escape sequence, for example,\x1B:

"1000\t2000" =~ m(0\t2) # corresponds to "cat" =~ /\143\x61\x74/ # corresponds to ASCII, but #cat is misspelled

Regular expressions are mostly treated as double-quoted strings, so variable substitution works:

$foo = 'casa'; 'gathouse' =~ /gato$foo/; # fall with 'housecat' =~ /${foo}gato/; # collapse

For all of the above regular expressions, the regular expression is considered a match if it matches anywhere in the string. indicateWomust match, we will use itAnkermetacharacters^jPS.Anker^means that the beginning of the string and the anchor matchPSmeans match at the end of the string or before a newline at the end of the string. Some examples:

"housekeeper" =~ /keeper/; # matches "housekeeper" =~ /^keeper/; # does not match "housekeeper" =~ /maid$/; # matches "housekeeper\n" =~ /maid$/; # matches "housekeeper" =~ /^housekeeper$/; # Matches

#Use character classes

Acharacter classAllows you to match a range of possible characters at a given location in a regular expression, not just one character. There are many different types of character classes, but generally the use of the term means the types described in this section, which are technically called "parenthesized character classes" because they are specified in parentheses.[...], which contains the set of possible matching characters. However, we will remove the "brackets" below to conform to common usage. Here are some examples of character classes (in parentheses):

/gato/; # matches 'gato'/[bcr]at/; # matches 'murciélago', 'gato' or 'rata' "abc" =~ /[taxi]/; # matches "a".

However, in the final statement'C'is the first character of the class, the first period that the regular expression can match'A'.

/[yY][eE][sS]/; # matches "yes", case insensitive # "yes", "Yes", "YES", etc./yes/i; # also written in a case-insensitive form that matches "Yes".

The last example shows the same thing.'I' modifier, which makes the match case-insensitive.

There are ordinary and special characters within character classes, but the set of ordinary and special characters within a character class is different from the set outside of a character class. Special characters for character classes are-]\^$And use the escape match:

/[\]c]def/; # matches ']def' or 'cdef' $x = 'bcr';/[$x]at/; # matches 'murciélago', 'gato', or 'rata'/[\ $x]at/; # matches '$at' or 'xat'/[\\$x]at/; # matches '\at', 'bat', 'cat', or 'rat'

special character'-'Acts as a scope operator for character classes, making it unwieldy to use[0123456789]j[abc...xyz]lose weight[0-9]j[Arizona]:

/item[0-9]/; # matches 'item0' or ... or 'item9'/[0-9a-fA-F]/; # matches hexadecimal digits

And'-'is the first or last character of a character class, treated like an ordinary character.

special character^First in a character class meansnegated character class, which matches any character except those in parentheses. both[...]j[^...]A single character must match; otherwise the match fails. So

/[^a]in/; # does not match 'aat' or 'at', but does match # all other 'bat', 'cat, '0at', '%at', etc. /[^0-9]/ ; # Matches a non-digit character /[a^]at/; # matches 'aat' or '^at'; here '^' is normal

Perl has shortcuts for several commonly used character classes. (These definitions are used by Perl in Safe ASCII mode/AOtherwise, they can also match more non-ASCII Unicode characters. see"Backslash sequence" in PerlrecharclassLearn more. )

• \d is a number that represents

  (Video) Perl part 1: Introduction to Perl

  [0-9]

• \s is a space that represents

  [\\t\r\n\f]

• \w is a word character (alphanumeric or _) representing

  [0-9a-zA-Z_]

• \D is a negated \d; represents any character except a digit

  [^0-9]

• \S is a negated \s; represents any character that is not a space

  [^\s]

• \W is a negated \w; represents any character that is not a word

  [^\n]

• Period'. ' matches any character except "\n"

It is\d\s\w\D\S\WAbbreviations can be used both inside and outside of character classes. Here are some that are in use:

/\d\d:\d\d:\d\d/; # corresponds to hh:mm:ss time format /[\d\s]/; # matches any number or space /\w\W\w/ ; # matches a word char followed by # char that is not a word followed by a word char/..rt/; # matches any two characters followed by 'rt'/end\./; # matches "end". /End[.]/; # same, equals "end".

It isback \BMatches the boundary between a word character and a non-word character\w\WÖ\w\w:

$x = "Housecat combines house and cat";$x =~ /\bcat/; # matches cats in "catenates" $x =~ /cat\b/; # matches cats in 'housecat' $x =~ /\ bcat\b/; # matches "cat" at the end of the string

In the last example, the end of the string is considered a word boundary.

Use for natural language processing (e.g. words with apostrophes) instead.\b{wb}

"no" = ~/.+? \b{wb} /x; # matches the entire string

#fits this or that

We can combine different stringsAlternativemetacharacters'|'.PhosphorDogÖGato, we form the regular expressiondog | Cat.As before, Perl tries to find the regular expression as early in the string as possible. At each character position, Perl first tries to find the first alternative,Dog.AndDogdoes not match, Perl tries the following alternative:Gato.AndGatoNo match, then the match fails and Perl moves to the next position in the chain. Some examples:

"Cats and Dogs" =~ /cat|dog|bird/; # matches "cat" "cats and dogs" =~ /dog|cat|bird/; # matches "cat".

AlthoughDogis the first option in the second regular expression,GatoAbility to match at the beginning of a string.

"cats" =~ /c|ca|cat|cats/; # matches "c" "cats" =~ /cats|cat|ca|c/; # matches "cats"

At a given character position, the first option that allows the regular expression to match correctly is the one that matches. Here all alternatives match at the first position in the string, i.e. the first matches.

#Hierarchical clustering and matching

It isgroupmetacharacters()Allows you to treat part of a regular expression as a unit. Parts of a regular expression are grouped by enclosing them in parentheses. regular phrasehouse (cat | breeder)means coincidenceCasafollowed byGatoÖgoalie.Other examples are

/(a|b)b/; # matches 'ab' or 'bb'/(^a|b)c/; # matches "ac" at the beginning of the string or "bc" anywhere /home(cat|)/; # matches 'house cat' or 'house'/house(cat(s|)|)/; # matches "domestic cat" or "domestic cat" or # "house". Groups of notes can be nested. "20" =~ /(19|20|)\d\d/; # matches the null alternative '()\d\d', # because '20\d\d' cannot be found

#extract matches

group metacharacters()You can also use it to extract matching string parts. For each grouping, the internal match part goes into a special variable1 $,2 $Wait. They can be used as normal variables:

# extract hours, minutes, seconds $time =~ /(\d\d):(\d\d):(\d\d)/; # conforms to the format hh:mm:ss $hours = $1;$minutes = $2;$seconds = $3;

In list context matches/normal Sentence/with groupings returns a list of matching values($1,$2,...).so we can rewrite it as

($hours, $minutes, $seconds) = ($time =~ /(\d\d):(\d\d):(\d\d)/);

If the groupings in the regular expression are nested,1 $Get the leftmost opening parenthesis group,2 $next left parenthesis, etc. For example, here is a complex regular expression and matching variables:

/(ab(cd|ef)((gi)|j))/; 1 2 34

Link to match variable1 $,2 $, ... Andlater reference \g1,\g2, ... backreferences are match variables that can be usedInRegular sentence:

/(\w\w\w)\s\g1/; # Find sequences like "the" in the string

1 $,2 $, ... can only be used outside regular expressions, and\g1,\g2, ... only within regular expressions.

#double match

It isQuantormetacharacters?,*,+, and{}With this we can determine the number of repetitions of the part of the regular expression that we consider a match. The quantifier comes immediately after the character, character class, or grouping that we want to specify. They have the following meaning:

• A?= matches 'a' 1 or 0 times

• A*= matches 'a' 0 or more times, i.e. H. any number of times

• and += matches 'a' 1 or more times, i.e. H. at least once

• a {n,m}= at least matchnortetimes, but no more thanReissecond rate.

• like,}= at least matchnorteor more often

• like}= PartynorteAt least sometimes

• like}= exact matchnortesecond rate

Here are some examples:

/[a-z]+\s+\d*/; # matches a lowercase word, at least some spaces, and # any number of digits /(\w+)\s+\g1/; # matches double words of any length $year = ~ /^\d{2,4}$/; # Make sure the year has at least 2 but no more # 4 digits $year =~ /^\d{ 4 }$|^\d{2}$/ ; # best match; Discard three-digit dates

These quantifiers try to match as many strings as possible and still allow regular expression matches. so we have

$x = 'the cat in the hat'; $x =~ /^(.*)(at)(.*)$/; # matches, # $1 = 'the cat in h' # $2 = 'at' # $3 = '' (0 matches)

first quantifier.*Get as much of the string as possible while maintaining regular expression matching. second quantifier.*Since there is no more string, it will match 0 times.

#further placements

There are a few other things you might want to know about the match operators. global modifier/ GRAMMThe match operator can match as many times as possible in the string. In a scalar context, consecutive matches are made on strings/ GRAMMJump from one game to the next while keeping an eye on your position in the chain. You can get or set the location withLocation()Function. For example,

$x = "猫狗屋"; # 3 words while ($x =~ /(\w+)/g) { print "word is $1, ends at position", pos $x, "\n";}

Impression

The word is cat, the word ending in position 3 is dog, the word ending in position 7 is house, the word ending in position 13

A failed match or change in the target string resets the position. If you don't want to reset the position after a failed match, add/C, if/regex/GC.

In the context of the list/ GRAMMReturns a list of matching groupings, or if there are no groupings, the full list of regular expression matches. So

@words = ($x =~ /(\w+)/g); # 匹配，# $word[0] = 'cat' # $word[1] = 'dog' # $word[2] = 'house'

#search and replace

Search and replace is done withs/regex/replacement/modifier.It isalternativesis a Perl double-quoted string that replaces strings withregular phrase.Operator=~Also used here to compare stringsfew///.if they agreePS, It is$_ =~can be ruled out. if there is a gamefew///Returns the number of replacements; otherwise false is returned. Here are some examples:

$x = "Time to feed the cat!";$x =~ s/cat/hacker/; # $x contains "Time to feed the hacker!" $y = "'words in quotes'";$y =~ s /^'(.*)'$/$1/; # remove single quotes, # $y contains "quotes"

Withfew///operator, variable to match1 $,2 $etc. They are immediately available for substitution expressions. With the global modifierseconds///gramsfinds and replaces all occurrences of the regular expression in the string:

$x = "I hit 4 of 4"; $x =~ s/4/four/; # $x contains "I hit 4 of 4" $x = "I hit 4 of 4"; $x =~ s/ 4/four/g; # $x contains "I played four against four"

lossless modifiers///rCauses the result of the replacement to be returned and not modifiedPS(or any variable bound by the replacement=~):

$x = "I like dogs.";$y = $x =~ s/dogs/cats/r;print "$x $y\n"; # print “I like dogs. I like cats." $x = "Cats are cool.";print $x =~ s/Cats/Dogs/r =~ s/Dogs/Frogs/r =~ s/Frogs/Hedgehogs /r, "\n" ;# Print " Hedgehogs are cool."@foo = map { s/[a-z]/X/r } qw(a b c 1 2 3);# @foo is now qw(X X X 1 2 3 )

rating modifierTrumpet /// Trumpetwrap oneEvaluate{...}Encloses the replacement string and replaces the result of the evaluation with the matching substring. Some examples:

# reverse all words in string $x = "the cat in the hat"; $x =~ s/(\w+)/reverse $1/ge; # $x contains "eht tac ni eht tah" # convert percentage convert to decimal $x = "A hit rate of 39%";$x =~ s!(\d+)%!$1/100!e; # $x contains "A hit rate of 0.39"

The last example showsfew///Other delimiters can also be used, e.g！jfew{}{}, it is includedS{}//.if you use single quotesfew''', regular expressions, and substitutions are treated as single-quoted strings.

#division operator

split/regex/, stringTo shareChainGo to a list of substrings and return that list. regular expression to determine the character stringChainas opposed to division. For example, to split a string into words, use

$x = "Calvin and Hobbes";@word = split /\s+/, $x; # $word[0] = 'Calvin' # $word[1] = 'and' # $word[2] = 'Hobbes '

To extract a comma-separated list of numbers, use

$x = "1.618,2.718, 3.142";@const = split /,\s*/, $x; # $const[0] = '1.618' # $const[1] = '2.718' # $const[2] = '3.142'

if the regular expression is empty//When used, the string is split into individual characters. If the regular expression has groupings, the resulting list also contains matching substrings of the grouping:

$x = "/usr/bin";@parts = dividiere m!(/)!, $x; # $parts[0] = '' # $parts[1] = '/' # $parts[2] = 'usr' # $parts[3] = '/' # $parts[4] = 'bin'

Since the first character of $x matches the regular expression,To shareAdd an empty initial element to the list.

#use re "strict"

New in version 5.22: This enforces stricter rules when compiling regex patterns than would otherwise be possible. You may find things that are legitimate but may not be what you are looking for.

seerestrict".

not everyone.

This is just a quick guide. For a more detailed guide on regular expressions, seeperlretutReference pages can be found hereperla.

Copyright (c) 2000 Mark Kvale All rights reserved.

This document may be distributed under the same terms as Perl itself.

#gracias

The authors would like to thank Mark-Jason Dominus, Tom Christiansen, Ilya Zakharevich, Brad Hughes, and Mike Giroux for all their helpful comments.