Regular expressions: Difference between revisions
→{{header|langur}}
Alextretyak (talk | contribs) (Added 11l) |
Langurmonkey (talk | contribs) |
||
(15 intermediate revisions by 12 users not shown) | |||
Line 3:
{{omit from|BASIC}}
{{omit from|Brlcad}}
{{omit from|EasyLang}}
{{omit from|GUISS}}
{{omit from|PARI/GP}}
Line 15 ⟶ 16:
{{trans|Python}}
<
I re:‘string$’.search(string)
Line 21 ⟶ 22:
string = string.replace(re:‘ a ’, ‘ another ’)
print(string)</
{{out}}
Line 30 ⟶ 31:
=={{header|8th}}==
<
"haystack" /a./ r:match . cr
"haystack" /a./ "blah" s:replace! . cr
</syntaxhighlight>
{{out}}
<pre>
Line 42 ⟶ 43:
=={{header|ABAP}}==
<syntaxhighlight lang="abap">
DATA: text TYPE string VALUE 'This is a Test'.
Line 54 ⟶ 55:
cl_demo_output=>write( text ).
cl_demo_output=>display( ).
</syntaxhighlight>
Output:
Line 66 ⟶ 67:
There is no Regular Expression library in the Ada Standard,
so I am using one of the libraries provided by gnat/gcc.
<
procedure Regex is
Line 108 ⟶ 109:
Str := Str(Str'First .. First-1) & "pattern" & Str(Last+1 .. Str'Last);
Put_Line(Str);
end Regex;</
{{out}}
Line 123 ⟶ 124:
<!-- {{does not work with|ALGOL 68|Standard - grep/sub in string are not part of the standard's prelude. }} -->
{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}
<
STRING str := "i am a string";
Line 135 ⟶ 136:
# Replace: #
IF sub in string(" a ", " another ",str) = match THEN printf(($gl$, str)) FI;</
{{out}}
<pre>
Line 151 ⟶ 152:
{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}
For example:<
FILE file; STRING book; associate(file, book);
on value error(file, (REF FILE f)BOOL: stop);
Line 162 ⟶ 163:
print(("Dalmatians: ", dalmatians, new line));
count OF dalmatians +:=1;
printf(($"Gives: "$, pattern, dalmatians, $l$))</
{{out}}
<pre>
Dalmatians: +100 +2
Gives 101 dogs
</pre>
=={{header|Amazing Hopper}}==
task 1: match a string against a regular expression (Hopper use POSIX):
<syntaxhighlight lang="amazing hopper">
#include <hopper.h>
main:
expReg="[A-Z]{1,2}[0-9][0-9A-Z]? +[0-9][A-Z]{2}"
flag compile = REG_EXTENDED
flag match=0
número de matches=10, T1=0
{flag compile,expReg} reg compile(T1) // compile regular expression, pointed whit T1
{flag match,número de matches,T1,"We are at SN12 7NY for this course"},reg match, // execute
println
reg free(T1) // free pointer to regular expression compiled.
exit(0)
</syntaxhighlight>
{{out}}
<pre>
11 18 SN12 7NY
</pre>
Task 2: Hopper does not substitute using regular expressions, but using proper functions.
<syntaxhighlight lang="amazing hopper">
#include <hopper.h>
main:
expReg="[A-Z]{1,2}[0-9][0-9A-Z]? +[0-9][A-Z]{2}"
cadena = "We are at SN12 7NY for this course"
flag compile = REG_EXTENDED
flag match=0
número de matches=10, T1=0
{flag compile,expReg} reg compile(T1) // compile regular expression, pointed whit T1
{flag match,número de matches,T1,cadena},reg match, // execute
matches=0,mov(matches)
reg free(T1) // free pointer to regular expression compiled.
From=0, To=0, toSearch=""
[1,1]get(matches), mov(From)
[1,2]get(matches), mov(To)
[1,3]get(matches), mov(toSearch)
// substitute with "transform":
{"another thing",toSearch,cadena}transform, println
// substitute with "delete"/"insert":
{To}minus(From),plus(1), {From, cadena} delete, mov(cadena)
{From,"another thing",cadena}insert , println
exit(0)
</syntaxhighlight>
{{out}}
<pre>
We are at another thing for this course
We are at another thing for this course
</pre>
=={{header|AppleScript}}==
{{libheader|Satimage.osax}}
<
find text ".*string$" in "I am a string" with regexp
on error message
Line 181 ⟶ 241:
on error message
return message
end try</
----
As from macOS 10.14 Mojave, third-party scripting additions (OSAXen) such as the Satimage OSAX are essentially unusable. (One of Apple's increasingly tight security measures.) They ''are'' allowed under very strict conditions as part of an application's own resources and [https://latenightsw.com Late Night Software], the developer of Script Debugger, has released a [https://forum.latenightsw.com/t/use-satimage-scripting-additions-on-catalina-and-mojave/1576 SatimageOSAX] application as a stop-gap measure to allow existing Satimage-dependent scripts to be used with minimal editing until they're rewritten to use other commands.
Line 188 ⟶ 248:
'''do shell script:'''
<
try
set output to (do shell script "echo 'I am a string' | egrep -o '\\S+$'")
Line 196 ⟶ 256:
-- Replace the first instance of "orig…" with "modified".
set moreOutput to(do shell script "echo 'I am the original string' | sed 's/orig[a-z]*/modified/'")
return output & linefeed & moreOutput</
'''ASObjC''' uses [http://userguide.icu-project.org/strings/regexp ICU regex]:
<
use framework "Foundation"
Line 222 ⟶ 282:
end if
return (output as text) & linefeed & moreOutput</
As an alternative to the NSString regex options used above, there's also a dedicated NSRegularExpression class:
<
use framework "Foundation"
Line 247 ⟶ 307:
end if
return (output as text) & linefeed & moreOutput</
{{out}}
Line 257 ⟶ 317:
=={{header|Argile}}==
<
(: matching :)
Line 278 ⟶ 338:
uninit regex
check mem leak; use dbg (:optional:)</
(note that it needs to be compiled with argrt library)
Line 289 ⟶ 349:
=={{header|Arturo}}==
<
if contains? s
replace 's
print s</
{{out}}
Line 303 ⟶ 363:
=={{header|AutoHotkey}}==
<
MsgBox % replaced := RegExReplace("Hello World", "World$", "yourself")</
=={{header|AWK}}==
AWK supports regular expressions, which are typically enclosed using slash symbols at the front and back, and the tilde regular expression binding operator:
<
abc
ABC
uppercase detected</
As shorthand, a regular expression in the condition part fires if it matches an input line:
<
def
DeF
uppercase detected</
For substitution, the first argument can be a regular expression, while the replacement string is constant (only that '&' in it receives the value of the match):
<
abCDefG
ab**ef*
$ awk '{gsub(/[A-Z]/,"(&)");print}'
abCDefGH
ab(C)(D)ef(G)(H)</
This variant matches one or more uppercase letters in one round:
<
abCDefGH
ab(CD)ef(GH)</
Regular expression negation can be achieved by combining the regular expression binding operator with a logical not operator, as follows:
Line 338 ⟶ 398:
{{works with|BBC BASIC for Windows}}
Uses the [http://people.delphiforums.com/gjc/gnu_regex.html gnu_regex] library.
<
IF gnu_regex% = 0 ERROR 100, "Cannot load gnu_regex.dll"
SYS "GetProcAddress", gnu_regex%, "regcomp" TO regcomp
Line 377 ⟶ 437:
ENDIF
SYS "FreeLibrary", gnu_regex%</
{{out}}
<pre>
Line 396 ⟶ 456:
List all rational numbers smaller then 7 hidden in the string "fgsakg789/35768685432fkgha"
<
{{out}}
<pre>789/357
Line 421 ⟶ 481:
Test
<
true? str.match(/string$/)
Line 428 ⟶ 488:
false? str.match(/^You/)
{ p "Does not start with 'You'" }
</syntaxhighlight>
Substitute
<
str2 = str.sub(/ a /, " another ")
Line 451 ⟶ 511:
p str # prints "I Am Another string"
</syntaxhighlight>
=={{header|C}}==
Line 458 ⟶ 518:
As far as I can see, POSIX defined function for regex matching, but nothing for substitution. So we must do all the hard work ''by hand''. The complex-appearing code could be turned into a function.
<
#include <stdlib.h>
#include <sys/types.h>
Line 500 ⟶ 560:
return 0;
}</
===Alternative using GLib===
The task is a bit easier with GLib's Perl-compatible regular expression functionality.
{{libheader|GLib}}
<
#include <glib.h>
Line 558 ⟶ 618:
regex_replace_demo();
return 0;
}</
{{out}}
Line 569 ⟶ 629:
=={{header|C sharp}}==
<
using System.Text.RegularExpressions;
Line 583 ⟶ 643:
Console.WriteLine(str);
}
}</
=={{header|C++}}==
{{works with|g++|4.0.2 (may need to be retested?)}}
Standards earlier than C++11 can make use of Boost's Regex library via boost/regex.hpp
<syntaxhighlight lang="cpp">#include <iostream>
#include <string>
#include <iterator>
#include <
int main()
{
std::string s = "Hi, I am a string";
// match the complete string
if (
std::cout << "The string matches.\n";
else
Line 606 ⟶ 666:
// match a substring
if (
{
std::cout << "Matched " << match.length()
Line 622 ⟶ 682:
// replace a substring
std::string dest_string;
s.begin(), s.end(),
re2,
"'m now a changed");
std::cout << dest_string << std::endl;
}</
=={{header|Clojure}}==
<
;; match
(when (re-find #"string$" s)
Line 639 ⟶ 699:
;; substitute
(println (clojure.string/replace s " a " " another "))
)</
=={{header|Common Lisp}}==
Line 646 ⟶ 706:
Uses [http://weitz.de/cl-ppcre/ CL-PPCRE - Portable Perl-compatible regular expressions for Common Lisp].
<
(when (cl-ppcre:scan "string$" string)
(write-line "Ends with string"))
(unless (cl-ppcre:scan "^You" string )
(write-line "Does not start with 'You'")))</
Substitute
<
(string (cl-ppcre:regex-replace " a " string " another ")))
(write-line string))</
Test and Substitute
<
(multiple-value-bind (string matchp)
(cl-ppcre:regex-replace "\\bam\\b" string "was")
(when matchp
(write-line "I was able to find and replace 'am' with 'was'."))))</
===CLISP regexp engine===
{{works with|CLISP}}
[[Clisp]] comes with [http://clisp.org/impnotes/regexp-mod.html built-in regexp matcher]. On a Clisp prompt:
<
#S(REGEXP:MATCH :START 6 :END 9)</
To find all matches, loop with different <code>:start</code> keyword.
Replacing text can be done with the help of <code>REGEXP:REGEXP-SPLIT</code> function:
<
(reduce #'(lambda (x y) (string-concat x repl y))
(regexp:regexp-split pat string)))
REGEXP-REPLACE
[3]> (regexp-replace "x\\b" "-X-" "quick foxx jumps")
"quick fox-X- jumps"</
=={{header|D}}==
<
import std.stdio, std.regex;
Line 693 ⟶ 753:
// Substitute.
s.replace(" a ".regex, " another ").writeln;
}</
{{out}}
<pre>Ends with 'string'.
Line 700 ⟶ 760:
=={{header|Dart}}==
<
String capitalize(Match m) => '${m[0].substring(0, m[0].length-1).toUpperCase()}';
Line 709 ⟶ 769:
print(hello);
print(hellomodified);
}</
{{out}}
<pre>hello hello! world world!
Line 717 ⟶ 777:
{{libheader| System.RegularExpressions}}
Sample program that uses a regex, for translate a line of code in cpp to pascal.
<syntaxhighlight lang="delphi">
program Regular_expressions;
Line 751 ⟶ 811:
end.
</syntaxhighlight>
{{out}}
Line 767 ⟶ 827:
=={{header|Elixir}}==
Elixir allows pattern matching using the <code>~r</code> sigil.
<syntaxhighlight lang="elixir">
str = "This is a string"
if str =~ ~r/string$/, do: IO.inspect "str ends with 'string'"
</syntaxhighlight>
A number of modifiers can be appended to the regular expression; <code>~r/pattern/i</code>, for instance, toggles case insensitivity.
<syntaxhighlight lang="elixir">
str =~ ~r/this/ # => false
str =~ ~r/this/i # => true
</syntaxhighlight>
Both <code>Regex</code> and <code>String</code> have a <code>replace</code> function.
<syntaxhighlight lang="elixir">
str1 = ~r/a/ |> Regex.replace(str,"another")
str2 = str1 |> String.replace(~r/another/,"even another")
</syntaxhighlight>
<code>Regex.replace</code> allows for a function to be used as a replacement value. A function can modify the found pattern.
<syntaxhighlight lang="elixir">
str3 = ~r/another/ |> Regex.replace(str2, fn x -> "#{String.upcase(x)}" end)
</syntaxhighlight>
{{out}}
Line 795 ⟶ 855:
=={{header|Emacs Lisp}}==
<syntaxhighlight lang="lisp">(let ((string "I am a string"))
(
(
(message "%s" (replace-regexp-in-string " a " " another " string)))</syntaxhighlight>
{{out}}
Ends with 'string'
I am another string
=={{header|Erlang}}==
<
String = "This is a string",
case re:run(String, "string$") of
Line 834 ⟶ 876:
String = "This is a string",
NewString = re:replace(String, " a ", " another ", [{return, list}]),
io:format("~s~n",[NewString]).</
=={{header|F_Sharp|F#}}==
{{trans|C#}}
<
open System.Text.RegularExpressions
Line 848 ⟶ 890:
let rstr = Regex(" a ").Replace(str, " another ")
Console.WriteLine(rstr)
0</
=={{header|Factor}}==
<
IN: rosetta-code.regexp
Line 858 ⟶ 900:
"1001" R/ 10+/ re-contains? . ! Does the string contain the regexp anywhere?
"blueberry pie" R/ \p{alpha}+berry/ "pumpkin" re-replace print</
{{out}}
<pre>
Line 870 ⟶ 912:
{{libheader|Forth Foundation Library}}
Test/Match
<
\ Create a regular expression variable 'exp' in the dictionary
Line 888 ⟶ 930:
[ELSE]
.( No match.) cr
[THEN]</
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">
Dim As String text = "I am a text"
If Right(text, 4) = "text" Then
Print "'" + text + "' ends with 'text'"
End If
Dim As Integer i = Instr(text, "am")
text = Left(text, i - 1) + "was" + Mid(text, i + 2)
Print "replace 'am' with 'was' = " + text
Sleep
</syntaxhighlight>
{{out}}
<pre>'I am a text' ends with 'text'
replace 'am' with 'was' = I was a text</pre>
=={{header|Frink}}==
Pattern matching:
<
line = "My name is Inigo Montoya."
Line 900 ⟶ 960:
println["Last name is: $last"]
}
</syntaxhighlight>
Replacement: (Replaces in the variable <code>line</code>)
<
line =~ %s/Frank/Frink/g
</syntaxhighlight>
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=5a2a1052f8dff12596fa7f45242d25a9 Click this link to run this code]'''
<
Dim sString As String = "Hello world!"
Line 919 ⟶ 979:
Print sString
End </
Output:
<pre>
Line 931 ⟶ 991:
<br />
Replacement:<br />
<
&string = &string.ReplaceRegEx("Another (Match)", "Replacing $1") // Using replace groups</
Check match:
<
// The string ends with "regex"
EndIf</
Split RegEx:
<
Matches:
<
For &RegExMatch In &RegExMatchCollection
&FullMatch = &RegExMatch.Value // &FullMatch contains the full pattern match: "pattern"
Line 946 ⟶ 1,006:
// &matchVarchar contains group matches: "pa", "ern"
EndFor
EndFor</
Flags: <br />
s - Dot matches all (including newline) <br />
Line 953 ⟶ 1,013:
Using Flags Sintax: (?flags)pattern <br />
Example:<br />
<
Error Handling:
<
&RegExMatchCollection = &string.Matches("[z-a]") // invalid pattern: z-a
&errCode = RegEx.GetLastErrCode() // returns 0 if no error and 1 if an error has occured
&errDsc = RegEx.GetLastErrDescription()</
=={{header|Genie}}==
<
/* Regular expressions, in Genie */
Line 977 ⟶ 1,037:
except err:RegexError
print err.message</
{{out}}
Line 986 ⟶ 1,046:
=={{header|Go}}==
<
import "fmt"
import "regexp"
Line 1,001 ⟶ 1,061:
result := pattern.ReplaceAllString(str, "modified")
fmt.Println(result)
}</
=={{header|Groovy}}==
"Matching" Solution (it's complicated):
<
def woodchuck = "How much wood would a woodchuck chuck if a woodchuck could chuck wood?"
Line 1,058 ⟶ 1,118:
println ("'${woodchuck}' ${wwNotMatches ? 'does not' : 'does'} match '${woodRE}' exactly")
println ("'${woodchuck}' ${wwMatches ? 'does' : 'does not'} match '${containsWoodRE}' exactly")</
{{out}}
Line 1,078 ⟶ 1,138:
Replacement Solution (String.replaceAll()):
<
{{out}}
Line 1,084 ⟶ 1,144:
Reusable Replacement Solution (Matcher.replaceAll()):
<
println (ck.replaceAll("CHUCK"))
println (ck.replaceAll("wind"))
Line 1,094 ⟶ 1,154:
println (ck.replaceAll("man"))
println (ck.replaceAll("work"))
println (ck.replaceAll("pickle"))</
{{out}}
Line 1,110 ⟶ 1,170:
=={{header|Haskell}}==
Test
<
str = "I am a string"
Line 1,116 ⟶ 1,176:
case matchRegex (mkRegex ".*string$") str of
Just _ -> putStrLn $ "ends with 'string'"
Nothing -> return ()</
Substitute
<
orig = "I am the original string"
result = subRegex (mkRegex "original") orig "modified"
putStrLn $ result</
=={{header|HicEst}}==
<
REAL, PARAMETER :: Regex=128, Count=256
Line 1,132 ⟶ 1,192:
vocals_changed = EDIT(Text=string, Option=Regex, Right="[aeiou]", RePLaceby='**', DO=LEN(string) ) ! changes 11
WRITE(ClipBoard) string ! Th** q****ck br**wn f**x j**mps **v**r th** l**zy d**g</
=={{header|Icon}} and {{header|Unicon}}==
Line 1,139 ⟶ 1,199:
Additionally, there is a regular expression pattern compiler 'RePat' and other supporting functions and variables.
<
s := "A simple string"
Line 1,150 ⟶ 1,210:
end
link regexp # link to IPL regexp </
{{libheader|Icon Programming Library}}
[http://www.cs.arizona.edu/icon/library/procs/regexp.htm See regexp].
Line 1,161 ⟶ 1,221:
Inform's regex support is similar to Perl's but with some limitations: angle brackets are used instead of square brackets, there is no multiline mode, several control characters and character classes are omitted, and backtracking is slightly less powerful.
<
let T be "A simple string";
if T matches the regular expression ".*string$", say "ends with string.";
replace the regular expression "simple" in T with "replacement";</
=={{header|J}}==
Line 1,170 ⟶ 1,230:
J's regex support is built on top of PCRE.
<
str =: 'I am a string' NB. String used in examples.</
Matching:
<
1</
Substitution:
<
I am still a string</
Note: use<syntaxhighlight lang
=={{header|Java}}==
<syntaxhighlight lang="java">
/* match entire string against a pattern */
boolean isNumber = "-1234.567".matches("-?\\d+(?:\\.\\d+)?");
/* substitute part of string using a pattern */
String reduceSpaces = "a b c d e f".replaceAll(" +", " ");
</syntaxhighlight>
<syntaxhighlight lang="java">
import java.util.regex.Matcher;
import java.util.regex.Pattern;
...
/* group capturing example */
Pattern pattern = Pattern.compile("(?:(https?)://)?([^/]+)/(?:([^#]+)(?:#(.+))?)?");
Matcher matcher = pattern.matcher("https://rosettacode.org/wiki/Regular_expressions#Java");
if (matcher.find()) {
String protocol = matcher.group(1);
String authority = matcher.group(2);
String path = matcher.group(3);
String fragment = matcher.group(4);
}
</syntaxhighlight>
<syntaxhighlight lang="java">
/* split a string using a pattern */
String[] strings = "abc\r\ndef\r\nghi".split("\r\n?");
</syntaxhighlight>
<br />
An alternate demonstration
{{works with|Java|1.4+}}
Test
<
if (str.matches(".*string")) { // note: matches() tests if the entire string is a match
System.out.println("ends with 'string'");
}</
To match part of a string, or to process matches:
<
Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher(str);
while (m.find()) {
// use m.group() to extract matches
}</
Substitute
<
String result = orig.replaceAll("original", "modified");
// result is now "I am the modified string"</
=={{header|JavaScript}}==
Test/Match
<
// Two different ways to create the RegExp object
Line 1,224 ⟶ 1,313:
// matches[0] == "Hello world"
// matches[1] == "world"
var matches = re_PatternToMatch2.exec(subject);</
Substitute
<
// Perform a string replacement
// newSubject == "Replaced!"
var newSubject = subject.replace(re_PatternToMatch, "Replaced");</
=={{header|jq}}==
Line 1,239 ⟶ 1,328:
'''Test''':
<
yields: true
'''Substitutution''':
<
yields: "I am another string"
'''Substitution using capture''':
<
yields: "a-bc"
=={{header|Jsish}}==
<
var re = /s[ai]mple/;
Line 1,260 ⟶ 1,349:
var replaced = sentence.replace(re, "different");
printf("replaced sentence is: %s\n", replaced);</
{{out}}
Line 1,270 ⟶ 1,359:
{{trans|Perl}}
Julia implements Perl-compatible regular expressions (via the built-in [http://www.pcre.org/ PCRE library]). To test for a match:
<
if ismatch(r"string$", s)
println("'$s' ends with 'string'")
end</
To perform replacements:
<
s = replace(s, r" (a|an) ", " another ")</
There are many [http://docs.julialang.org/en/latest/manual/strings/#regular-expressions other features] of Julia's regular-expression support, too numerous to list here.
=={{header|Kotlin}}==
<
fun main(args: Array<String>) {
Line 1,290 ⟶ 1,379:
val s2 = s1.replace(r2, s3)
if (s2 != s1) println("`$s2` replaces `$r2` with `$s3`")
}</
{{out}}
Line 1,299 ⟶ 1,388:
=={{header|langur}}==
There are several functions that can be used with regexes, such as match(), replace(), split(), etc. They can also be matched
To match a string, ...
<
Or...
<syntaxhighlight lang="langur">if val .x, .y = submatch(re/(abc+).+?(def)/, "somestring") { ... }</syntaxhighlight>
Or...
<
case -> re/abc/: ...
...
}</
Or...
<
case "somestring": ...
...
}</
Substitution does not alter the original string.
<
# result: "Ydef"</
=={{header|Lasso}}==
Lasso has built in support for regular expressions using ICU regexps.
<
My name is: Hippo, Campus
')
Line 1,352 ⟶ 1,437:
#regexp -> reset(-input = #mytext)
'<br />'
#regexp -> replaceall</
<pre>Rosetta
Campus
Line 1,362 ⟶ 1,447:
In Lua many string manipulation methods use ''patterns'', which offer almost the same fucntionality as regular expressions, but whose syntax differs slightly. The percent sign (<code>%</code>) is generally used instead of a backslash to start a character class or a reference for a match in a substitution.
<
pattern = ".*name is (%a*).*"
Line 1,370 ⟶ 1,455:
sub, num_matches = test:gsub(pattern, "Hello, %1!")
print(sub)</
=={{header|M2000 Interpreter}}==
Line 1,384 ⟶ 1,469:
Enumerators for some COM objects are number of function -4&, we can use this in place of string for the name of property.
<syntaxhighlight lang="m2000 interpreter">
Module CheckIt {
declare global ObjRegEx "VBscript.RegExp"
Line 1,458 ⟶ 1,543:
}
Internal
</syntaxhighlight>
=={{header|M4}}==
<
regexp(`GNUs not Unix', `\<[a-z]\(\w+\)', `a \& b \1 c')</
{{out}}
Line 1,471 ⟶ 1,556:
=={{header|Maple}}==
<
StringTools:-RegMatch("^ab+bc$", "abbbbc");
StringTools:-RegMatch("^ab+bc$", "abbbbcx");
StringTools:-RegSub("a([bc]*)(c*d)", "abcd", "&-\\1-\\2");
StringTools:-RegSub("(.*)c(anad[ai])(.*)", "Maple is canadian", "\\1C\\2\\3");</
{{Out|Output}}
<pre>true
Line 1,482 ⟶ 1,567:
"Maple is Canadian"</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">StringCases["I am a string with the number 18374 in me",RegularExpression["[0-9]+"]]
The in-notebook output, in order:
<pre>{18374}
I'm a string</pre>
=={{header|MAXScript}}==
<syntaxhighlight lang="maxscript">
samples = #("Some string 123","Example text 123","string",\
"ThisString Will Not Match","A123,333,string","123451")
Line 1,534 ⟶ 1,615:
)
)
</syntaxhighlight>
{{Out}}
<pre>
Line 1,556 ⟶ 1,637:
=={{header|MIRC Scripting Language}}==
<
var %string = This is a string
var %re = string$
Line 1,568 ⟶ 1,649:
%re = \b(another)\b
echo -a Result 2: $regsubex(%string,%re,yet \1)
}</
{{out}}
Line 1,578 ⟶ 1,659:
=={{header|MUMPS}}==
<p>MUMPS doesn't have a replacement functionality when using the pattern matching operator, ?. We can mimic it with $PIECE, but $PIECE doesn't work with regular expressions as an operand.</p><
NEW HI,W,PATTERN,BOOLEAN
SET HI="Hello, world!",W="world"
Line 1,590 ⟶ 1,671:
SET BOOLEAN=$FIND(HI,W)
IF BOOLEAN>0 WRITE $PIECE(HI,W,1)_"string"_$PIECE(HI,W,2)
QUIT</
Usage:<pre>
USER>D REGEXP^ROSETTA
Line 1,600 ⟶ 1,681:
=={{header|NetRexx}}==
<
options replace format comments java crossref symbols nobinary
Line 1,637 ⟶ 1,718:
return
</syntaxhighlight>
{{out}}
<pre>
Line 1,654 ⟶ 1,735:
=={{header|NewLISP}}==
<syntaxhighlight lang="newlisp
=={{header|Nim}}==
<
var s = "This is a string"
Line 1,665 ⟶ 1,746:
s = s.replace(re"\ a\ ", " another ")
echo s</
=={{header|Objeck}}==
<
use RegEx;
Line 1,686 ⟶ 1,767:
}
}
</syntaxhighlight>
=={{header|Objective-C}}==
Line 1,692 ⟶ 1,773:
{{works with|Mac OS X|10.4+}}
{{works with|iOS|3.0+}}
<
NSString *regex = @".*string$";
Line 1,700 ⟶ 1,781:
if ([pred evaluateWithObject:str]) {
NSLog(@"ends with 'string'");
}</
Unfortunately this method cannot find the location of the match or do substitution.
Line 1,707 ⟶ 1,788:
{{works with|Mac OS X|10.7+}}
{{works with|iOS|3.2+}}
<
if ([str rangeOfString:@"string$" options:NSRegularExpressionSearch].location != NSNotFound) {
NSLog(@"Ends with 'string'");
}</
Substitute
{{works with|Mac OS X|10.7+}}
{{works with|iOS|4.0+}} undocumented
<
NSString *result = [orig stringByReplacingOccurrencesOfString:@"original"
withString:@"modified"
options:NSRegularExpressionSearch
range:NSMakeRange(0, [orig length])];
NSLog(@"%@", result);</
===NSRegularExpression===
Line 1,726 ⟶ 1,807:
{{works with|iOS|4.0+}}
Test
<
options:0
error:NULL];
Line 1,735 ⟶ 1,816:
].location != NSNotFound) {
NSLog(@"Ends with 'string'");
}</
Loop through matches
<
options:0
range:NSMakeRange(0, [str length])
Line 1,744 ⟶ 1,825:
// match.range gives the range of the whole match
// [match rangeAtIndex:i] gives the range of the i'th capture group (starting from 1)
}</
Substitute
<
NSRegularExpression *regex = [NSRegularExpression regularExpressionWithPattern:@"original"
options:0
Line 1,755 ⟶ 1,836:
range:NSMakeRange(0, [orig length])
withTemplate:@"modified"];
NSLog(@"%@", result);</
=={{header|OCaml}}==
=== With the standard library ===
Test
<
let str = "I am a string";;
try
Line 1,766 ⟶ 1,847:
print_endline "ends with 'string'"
with Not_found -> ()
;;</
Substitute
<
let orig = "I am the original string";;
let result = Str.global_replace (Str.regexp "original") "modified" orig;;
(* result is now "I am the modified string" *)</
=== Using Pcre ===
'''Library:''' [http://ocaml.info/home/ocaml_sources.html#pcre-ocaml ocaml-pcre]
<
try ignore(Pcre.exec ~pat str); (true)
with Not_found -> (false)
Line 1,786 ⟶ 1,867:
Printf.printf "Substitute: %s\n"
(Pcre.replace ~pat:"original" ~templ:"modified" "I am the original string")
;;</
=={{header|Ol}}==
<
; matching:
(define regex (string->regex "m/aa(bb|cc)dd/"))
Line 1,802 ⟶ 1,883:
(print (regex "aabcddx")) ; => false
</syntaxhighlight>
=={{header|ooRexx}}==
<
/* Using the RxRegExp Regular Expression built-in utility class */
Line 1,847 ⟶ 1,928:
::requires "rxregexp.cls"
</syntaxhighlight>
{{out}}
<pre>
Line 1,857 ⟶ 1,938:
=={{header|Oxygene}}==
<
// Match and Replace part of a string using a Regular Expression
//
Line 1,888 ⟶ 1,969:
end.
</syntaxhighlight>
Produces:
<pre>
Line 1,896 ⟶ 1,977:
=={{header|Oz}}==
<
[Regex] = {Module.link ['x-oz://contrib/regex']}
String = "This is a string"
Line 1,903 ⟶ 1,984:
{System.showInfo "Ends with string."}
end
{System.showInfo {Regex.replace String " a " fun {$ _ _} " another " end}}</
=={{header|Pascal}}==
<
// Match and Replace part of a string using a Regular Expression
//
Line 1,932 ⟶ 2,013:
if r.Exec(myResult) then writeln(' contains ' + r.Match[0]);
end.
</syntaxhighlight>
Produces:
<pre>
Line 1,943 ⟶ 2,024:
{{works with|Perl|5.8.8}}
Test
<
if ($string =~ /string$/) {
print "Ends with 'string'\n";
Line 1,950 ⟶ 2,031:
if ($string !~ /^You/) {
print "Does not start with 'You'\n";
}</
Substitute
<
$string =~ s/ a / another /; # makes "I am a string" into "I am another string"
print $string;</
In Perl 5.14+, you can return a new substituted string without altering the original string:
<
$string2 = $string =~ s/ a / another /r; # $string2 == "I am another string", $string is unaltered
print $string2;</
Test and Substitute
<
if ($string =~ s/\bam\b/was/) { # \b is a word border
print "I was able to find and replace 'am' with 'was'\n";
}</
Options
<
# g = globally (match as many as possible)
# i = case-insensitive
Line 1,978 ⟶ 2,059:
# m = multi-line (the expression is run on each line individually)
$string =~ s/i/u/ig; # would change "I am a string" into "u am a strung"</
Omission of the regular expression binding operators
Line 1,984 ⟶ 2,065:
If regular expression matches are being made against the topic variable, it is possible to omit the regular expression binding operators:
<
if (/banana/) { # The regular expression binding operator is omitted
print "Match found\n";
}</
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">\</span><span style="color: #000000;">regex</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"1.0.2"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (needs some recent bugfixes to regex.e for p2js)</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #008000;">"I am a string"</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\"%s\" %s with string\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">regex</span><span style="color: #0000FF;">(</span><span style="color: #008000;">`string$`</span><span style="color: #0000FF;">,</span><span style="color: #000000;">s</span><span style="color: #0000FF;">))?</span><span style="color: #008000;">"ends"</span><span style="color: #0000FF;">:</span><span style="color: #008000;">"does not end"</span><span style="color: #0000FF;">)})</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\"%s\" %s with You\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #008080;">iff</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">regex</span><span style="color: #0000FF;">(</span><span style="color: #008000;">`^You`</span><span style="color: #0000FF;">,</span><span style="color: #000000;">s</span><span style="color: #0000FF;">))?</span><span style="color: #008000;">"starts"</span><span style="color: #0000FF;">:</span><span style="color: #008000;">"does not start"</span><span style="color: #0000FF;">)})</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">gsub</span><span style="color: #0000FF;">(</span><span style="color: #008000;">`[A-Z]`</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"abCDefG"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"*"</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">gsub</span><span style="color: #0000FF;">(</span><span style="color: #008000;">`[A-Z]`</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"abCDefGH"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"(&)"</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">gsub</span><span style="color: #0000FF;">(</span><span style="color: #008000;">`[A-Z]+`</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"abCDefGH"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"(&)"</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">gsub</span><span style="color: #0000FF;">(</span><span style="color: #008000;">`string`</span><span style="color: #0000FF;">,</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"replacement"</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">gsub</span><span style="color: #0000FF;">(</span><span style="color: #008000;">`\ba\b`</span><span style="color: #0000FF;">,</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"another"</span><span style="color: #0000FF;">)</span> <span style="color: #0000FF;">?</span><span style="color: #000000;">s</span>
<span style="color: #0000FF;">?</span><span style="color: #000000;">gsub</span><span style="color: #0000FF;">(</span><span style="color: #008000;">`string`</span><span style="color: #0000FF;">,</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"replacement"</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
Line 2,014 ⟶ 2,099:
=={{header|PHP}}==
{{works with|PHP|5.2.0}}
<
# Test
if (preg_match('/string$/', $string))
Line 2,022 ⟶ 2,107:
# Replace
$string = preg_replace('/\ba\b/', 'another', $string);
echo "Found 'a' and replace it with 'another', resulting in this string: $string\n";</
{{out}}
Line 2,032 ⟶ 2,117:
PicoLisp doesn't have built-in regex functionality.
It is easy to call the native C library.
<
(use Preg
(native "@" "regcomp" 'I '(Preg (64 B . 64)) Pat 1) # Compile regex
(when (=0 (native "@" "regexec" 'I (cons NIL (64) Preg) String 0 0 0))
(prinl "String \"" String "\" matches regex \"" Pat "\"") ) ) )</
{{out}}
<pre>String "a7z" matches pattern "a[0-9]z"</pre>
Line 2,044 ⟶ 2,129:
Another possibility is dynamic pattern matching,
where arbitrary conditions can be programmed.
<
(use (@A @N @Z)
(and
(match '(@A "<" @N ">" @Z) (chop String))
(format @N)
(prinl @A "<" (inc @) ">" @Z) ) ) )</
{{out}}
<pre>The number <8> is incremented</pre>
=={{header|PowerShell}}==
<
"I am a string" -replace 'a\b','no' # I am no string</
By default both the <code>-match</code> and <code>-replace</code> operators are case-insensitive. They can be made case-sensitive by using the <code>-cmatch</code> and <code>-creplace</code> operators.
=={{header|PureBasic}}==
<
regex$ = "<([a-z]*)>[a-z,A-Z,0-9, ]*</\1>"
regex_replace$ = "letters[a-z,A-Z,0-9, ]*numbers[a-z,A-Z,0-9, ]*"
Line 2,067 ⟶ 2,152:
EndIf
Debug ReplaceRegularExpression(2, String$, "char stuff")
EndIf</
=={{header|Python}}==
<
string = "This is a string"
Line 2,078 ⟶ 2,163:
string = re.sub(" a ", " another ", string)
print(string)</
=={{header|R}}==
First, define some strings.
<
text1 <- "this is a matching string"
text2 <- "this does not match"</
Matching with grep. The indices of the texts containing matches are returned.
<
Matching with regexpr. The positions of the starts of the matches are returned, along with the lengths of the matches.
<
[1] 20 -1
attr(,"match.length")
[1] 6 -1
Replacement
<
[1] "this is a matching pair of socks" "this does not match"
=={{header|Racket}}==
<
#lang racket
Line 2,110 ⟶ 2,195:
(displayln (regexp-replace " a " s " another "))
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku"
say "It ends with 'string'";
}
Line 2,125 ⟶ 2,210:
# output:
# Xxx xxx Xxx xxx
</syntaxhighlight>
=={{header|Raven}}==
<
Match:
<
if "Ends with 'string'\n" print</
Replace once:
<
<
Replace all:
<
Replace case insensitive:
<
Splitting:
<syntaxhighlight lang
=={{header|REBOL}}==
<
Title: "Regular Expression Matching"
URL: http://rosettacode.org/wiki/Regular_expression_matching
Line 2,193 ⟶ 2,278:
replace string " another " " a " ; Change string back.
print [crlf "Replacement:" string]</
{{out}}
Line 2,210 ⟶ 2,295:
===testing===
<
$string="I am a string"
say 'The string is:' $string
Line 2,217 ⟶ 2,302:
z="ring" ; if pos(z,$string)\==0 then say 'It contains the string:' z
z="ring" ; if wordpos(z,$string)==0 then say 'It does not contain the word:' z
/*stick a fork in it, we're done.*/</
{{out}}
<pre>
Line 2,228 ⟶ 2,313:
===substitution (destructive)===
<
$string = "I am a string"
old = " a "
Line 2,237 ⟶ 2,322:
$string = changestr(old,$string,new)
say 'The changed string is:' $string
/*stick a fork in it, we're done.*/</
{{out}}
<pre>
Line 2,248 ⟶ 2,333:
===substitution (non-destructive)===
<
$string = "I am a string"
old = " a "
Line 2,258 ⟶ 2,343:
say 'The original string is:' $string
say 'The changed string is:' $string2
/*stick a fork in it, we're done.*/</
{{out}}
<pre>
Line 2,269 ⟶ 2,354:
===test and substitute===
<
$string = "I am a string"
old = " am "
Line 2,282 ⟶ 2,367:
say 'I was able to find and replace ' old " with " new
end
/*stick a fork in it, we're done.*/</
{{out}}
<pre>
Line 2,294 ⟶ 2,379:
=={{header|Ring}}==
<
# Project : Regular expressions
Line 2,304 ⟶ 2,389:
text = left(text,i - 1) + "was" + substr(text,i + 2)
see "replace 'am' with 'was' = " + text + nl
</syntaxhighlight>
Output:
<pre>
Line 2,313 ⟶ 2,398:
=={{header|Ruby}}==
Test
<
p "Ends with 'string'" if str =~ /string$/
p "Does not start with 'You'" unless str =~ /^You/</
Substitute
<
# Or:
str[/ a /] = ' another ' #=> "another"
str #=> "I am another string"</
Substitute using block
<
=={{header|Run BASIC}}==
<
if right$(string$,6) = "string" then print "'";string$;"' ends with 'string'"
i = instr(string$,"am")
string$ = left$(string$,i - 1) + "was" + mid$(string$,i + 2)
print "replace 'am' with 'was' = ";string$
</syntaxhighlight>
{{out}}
<pre>'I am a string' ends with 'string'
Line 2,339 ⟶ 2,424:
=={{header|Rust}}==
Note that <code>Regex::new</code> checks for a valid regex and thus returns a <code>Result<Regex, Error></code>.
<
fn main() {
Line 2,349 ⟶ 2,434:
println!("{}", Regex::new(" a ").unwrap().replace(s, " another "));
}</
=={{header|Sather}}==
Sather understands POSIX regular expressions.
<
-- we need to implement the substitution
regex_subst(re:REGEXP, s, sb:STR):STR is
Line 2,375 ⟶ 2,460:
#OUT + regex_subst(REGEXP::regexp("am +a +st", true), s, "get the ") + "\n";
end;
end;</
=={{header|Scala}}==
{{libheader|Scala}}
Define
<
val Bottles2 = """(\d+) bottles of beer""".r // using triple-quotes to preserve backslashes
val Bottles3 = new scala.util.matching.Regex("(\\d+) bottles of beer") // standard
val Bottles4 = new scala.util.matching.Regex("""(\d+) bottles of beer""", "bottles") // with named groups</
Search and replace with string methods:
<
"99 bottles of beer" replace ("99", "98") // Single replacement
"99 bottles of beer" replaceAll ("b", "B") // Multiple replacement</
Search with regex methods:
<
"\\w+".r findAllIn "99 bottles of beer" // returns all partial matches as an iterator
"\\s+".r findPrefixOf "99 bottles of beer" // returns a matching prefix, or None
Bottles4 findFirstMatchIn "99 bottles of beer" // returns a "Match" object, or None
Bottles4 findPrefixMatchOf "99 bottles of beer" // same thing, for prefixes
val bottles = (Bottles4 findFirstMatchIn "99 bottles of beer").get.group("bottles") // Getting a group by name</
Using pattern matching with regex:
<
for {
line <- """|99 bottles of beer on the wall
Line 2,411 ⟶ 2,496:
for {
matched <- "(\\w+)".r findAllIn "99 bottles of beer" matchData // matchData converts to an Iterator of Match
} println("Matched from "+matched.start+" to "+matched.end)</
Replacing with regex:
<
Bottles3 replaceAllIn ("99 bottles of beer", "98 bottles of beer")</
=={{header|SenseTalk}}==
Basic example showing the use of SenseTalk's pattern language to create a pattern, test for a match, find all matches, and replace a match.
<
set text to "This is a story about R2D2 and C3P0 who are best friends."
set pattern to <word start, letter, digit, letter, digit, word end>
Line 2,430 ⟶ 2,515:
replace the second occurrence of pattern in text with "Luke"
put text
</syntaxhighlight>
Output
<
True
(R2D2,C3P0)
This is a story about R2D2 and Luke who are best friends.
</syntaxhighlight>
Advanced example showing how to use capture groups within a pattern to reformat the names in a list.
<
set phoneList to {{
Harry Potter 98951212
Line 2,452 ⟶ 2,537:
replace every occurrence of namePattern in phoneList with "{:lastName}, {:firstName} –"
put phoneList
</syntaxhighlight>
Output
<
Potter, Harry – 98951212
Granger, Hermione – 59867125
Weasley, Ron – 56471832
</syntaxhighlight>
=={{header|Shiny}}==
<
Match text:
<
say "Ends with 'string'"
end</
Replace text:
<
=={{header|Sidef}}==
Simple matching:
<
if (str =~ /string$/) {
print "Ends with 'string'\n";
}</
Global matching:
<
x:Foo
y:Bar
Line 2,486 ⟶ 2,571:
while (var m = str=~/(\w+):(\S+)/g) {
say "#{m[0]} -> #{m[1]}";
}</
Substitutions:
<
# Substitute something mached by a regex
Line 2,500 ⟶ 2,585:
str = str.gsub(/(\w+)/, {|s1| 'x' * s1.len}); # globaly replace any word with 'xxx'
say str; # prints: 'x xx xxxxxx'</
=={{header|Slate}}==
Line 2,506 ⟶ 2,591:
This library is still in its early stages. There isn't currently a feature to replace a substring.
<
'http://slatelanguage.org/test/page?query' =~ '^(([^:/?#]+)\\:)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?'.
" ==> {'http:'. 'http'. '//slatelanguage.org'. 'slatelanguage.org'. '/test/page'. '?query'. 'query'. Nil} "
</syntaxhighlight>
=={{header|Smalltalk}}==
{{works with|GNU Smalltalk}}
<
re := Regex fromString: '[a-z]+ing'.
s := 'this is a matching string'.
Line 2,532 ⟶ 2,617:
].
(s replacingRegex: re with: 'modified') displayNl.</
{{works with|Pharo}}
<
|re s s1|
re := 'm[a-z]+ing' asRegex.
Line 2,543 ⟶ 2,628:
s1 := re copy: s replacingMatchesWith: 'modified'.
</syntaxhighlight>
=={{header|SNOBOL4}}==
Line 2,553 ⟶ 2,638:
SNOBOL4's "raison d'etre" is pattern matching and string manipulation (although it's also strong in data structures too). The basic statement syntax in SNOBOL4 is:
<
The basic operation is to evaluate the subject, evaluate the pattern, find the pattern in the subject, evaluate the object, and then replace the portion of the subject matched by the pattern with the evaluated object. If any of those steps fails (i.e. does not succeed) then execution continues with the goto, as appropriate.
Line 2,559 ⟶ 2,644:
The goto can be unconditional, or can be based on whether the statement succeeded or failed (and that is the basis for all explicit transfers of control in SNOBOL4). This example finds the string "SNOBOL4" in string variable string1, and replaces it with "new SPITBOL" (SPITBOL is an implementation of SNOBOL4, basically SPITBOL is to SNOBOL4 what Turbo Pascal is to Pascal):
<
string1 "SNOBOL4" = "new SPITBOL" :s(changed)f(nochange)</
The following example replaces "diameter is " and a numeric value by "circumference is " and the circumference instead (it also shows creation of a pattern which matches integer or real numeric values, and storing that pattern into a variable... and then using that pattern variable later in a slightly more complicated pattern expression):
<
dd = "0123456789"
string1 = "For the first circle, the diameter is 2.5 inches."
numpat = span(dd) (("." span(dd)) | null)
string1 "diameter is " numpat . diam = "circumference is " diam * pi</
Relatively trivial pattern matching and replacements can be attacked very effectively using regular expressions, but regular expressions (while ubiquitous) are a crippling limitation for more complicated pattern matching problems.
Line 2,576 ⟶ 2,661:
{{works with|SML/NJ}}
Test
<
structure RE = RegExpFn (
structure P = AwkSyntax
Line 2,589 ⟶ 2,674:
in
print ("matched at position " ^ Int.toString pos ^ "\n")
end;</
=={{header|Stata}}==
See '''[http://www.stata.com/help.cgi?regexm regexm]''', '''regexr''' and '''regexs''' in Stata help.
<
* is there a vowel?
Line 2,600 ⟶ 2,685:
* replace the first vowel with "?"
di regexr(s,"[aeiou]","?")</
=={{header|Swift}}==
Line 2,606 ⟶ 2,691:
===RegularExpressionSearch===
Test
<
let str = "I am a string"
if let range = str.rangeOfString("string$", options: .RegularExpressionSearch) {
println("Ends with 'string'")
}</
Substitute (undocumented)
<
let orig = "I am the original string"
let result = orig.stringByReplacingOccurrencesOfString("original", withString: "modified", options: .RegularExpressionSearch)
println(result)</
===NSRegularExpression===
Test
<
if let regex = NSRegularExpression(pattern: "string$", options: nil, error: nil) {
Line 2,629 ⟶ 2,714:
println("Ends with 'string'")
}
}</
Loop through matches
<
let match = x as! NSTextCheckingResult
// match.range gives the range of the whole match
// match.rangeAtIndex(i) gives the range of the i'th capture group (starting from 1)
}</
Substitute
<
let orig = "I am the original string"
Line 2,645 ⟶ 2,730:
let result = regex.stringByReplacingMatchesInString(orig, options: nil, range: NSRange(location: 0, length: count(orig.utf16)), withTemplate: "modified")
println(result)
}</
=={{header|Tcl}}==
Test using <code>regexp</code>:
<
if {[regexp -- {string$} $theString]} {
puts "Ends with 'string'"
Line 2,656 ⟶ 2,741:
if {![regexp -- {^You} $theString]} {
puts "Does not start with 'You'"
}</
Extract substring using <code>regexp</code>
<
if {[regexp -- {>(\d+)<} $theString -> number]} {
puts "Contains the number $number"
}</
Substitute using <code>regsub</code>
<
puts [regsub -- { +a +} $theString { another }]</
=={{header|Toka}}==
Line 2,672 ⟶ 2,757:
Toka's regular expression library allows for matching, but does not yet provide for replacing elements within strings.
<
needs regex
Line 2,690 ⟶ 2,775:
#! try-regex will return a flag. -1 is TRUE, 0 is FALSE
expression test.1 2 match try-regex .
expression test.2 2 match try-regex .</
=={{header|TXR}}==
Line 2,698 ⟶ 2,783:
Txr is not designed for sed-like filtering, but here is how to do <code>sed -e 's/dog/cat/g'</code>:
<
@(coll :gap 0)@mismatch@{match /dog/}@(end)@suffix
@(output)
@(rep)@{mismatch}cat@(end)@suffix
@(end)
@(end)</
How it works is that the body of the <code>coll</code> uses a double-variable match:
Line 2,723 ⟶ 2,808:
This allows for a very simple, straightforward regex which correctly matches C comments. The <code>freeform</code> operator allows the entire input stream to be treated as one big line, so this works across multi-line comments.
<
@(coll :gap 0)@notcomment@{comment /[/][*].%[*][/]/}@(end)@tail
@(output)
@(rep)@notcomment @(end)@tail
@(end)</
===Regexes in TXR Lisp===
Line 2,733 ⟶ 2,818:
Parse regex at run time to abstract syntax:
<
(compound #\a (0+ wild) #\b)</
Dynamically compile regex abstract syntax to regex object:
<
#<sys:regex: 9c746d0></
Search replace with <code>regsub</code>.
<
"b-d"</
=={{header|UNIX Shell}}==
Line 2,756 ⟶ 2,841:
{{works with|bash}}
{{works with|ksh}}
<
if [[ $s =~ str..g$ ]]; then
echo "the string ends with 'str..g'"
fi</
===Replacing===
Given these values
<
re='o.*l'
repl="modified"</
{{works with|ksh}}
Can use regular expressions in parameter expansion
<
echo "$modified" # I am the modified string</
{{works with|bash}}
have to break apart the original string to build the modified string.
<
submatch=${BASH_REMATCH[0]}
modified="${s%%$submatch*}$repl${s#*$submatch}"
echo "$modified" # I am the modified string
fi</
=={{header|Vala}}==
<
void main(){
string sentence = "This is a sample sentence.";
Line 2,795 ⟶ 2,880:
stdout.printf("Replaced sentence is: %s\n", sentence);
}
</syntaxhighlight>
{{out}}
Line 2,805 ⟶ 2,890:
=={{header|VBScript}}==
Replace white spaces with line breaks.
<
Set regex = New RegExp
regex.Global = True
Line 2,813 ⟶ 2,898:
Else
WScript.StdOut.Write "No matching pattern"
End If</
{{in}}
<pre>I need more coffee!!!</pre>
Line 2,828 ⟶ 2,913:
Match text at cursor location:
<
Statline_Message("This line ends with 'string'")
}</
Search for a pattern:
<
Statline_Message("'string' at and of line found")
}</
Replace:
<
=={{header|Web 68}}==
<
Web 68 has access to a regular expression module
which can compile regular expressions,
Line 2,898 ⟶ 2,983:
ca -l mod rosettacoderegex.w68
That's it. The resulting binary will print
'String "string$" matches string "This is a string"'</
=={{header|Wren}}==
===Version 1 (Wren-pattern)===
{{libheader|Wren-pattern}}
<
var s = "This is a story about R2D2 and C3P0 who are best friends."
Line 2,927 ⟶ 3,013:
var t = m.capsText
System.print(" %(t[1]), %(t[0]) - %(t[2])")
}</
{{out}}
Line 2,945 ⟶ 3,031:
Granger, Hermione - 59867125
Weasley, Ron - 56471832
</pre>
<br>
===Version 2 (Wren-regex)===
{{libheader|Wren-regex}}
The above module uses RE2 regular expression syntax but, since it is a wrapper for Go's 'regexp' package, it can only be used from a special embedded application and not by Wren-cli.
<syntaxhighlight lang="wren">/* Regular_expressions_2.wren */
import "./regex" for Regex
var s = "This is a story about R2D2 and C3P0 who are best friends."
var re = Regex.compile("""[A-Z]\d[A-Z]\d""")
var matches = re.findAll(s)
var indices = re.findAllIndex(s)
System.print("Original string:\n%(" %(s)")")
System.print("\nThe following matches were found:")
for (i in 0...matches.count) {
var m = matches[i]
var ix = indices[i][0]
System.print(" %(m) at index %(ix)")
}
System.print("\nAfter replacing the second match:")
System.print(" %(re.replaceAll(s, "Luke", 2, 1))") // replace 2nd match with "Luke"
System.print("\nReformatted phone list example:")
var phoneList = [
"Harry Potter 98951212",
"Hermione Granger 59867125",
"Ron Weasley 56471832"
]
var re2 = Regex.compile("""([A-Za-z]+) ([A-Za-z]+) (\d{8})""")
for (record in phoneList) {
var m = re2.findSubmatch(record)
System.print(" %(m[2]), %(m[1]) - %(m[3])")
}</syntaxhighlight>
{{out}}
<pre>
Identical to first version.
</pre>
Line 2,950 ⟶ 3,076:
The build in RE engine is a basic one.<br/>
Strings are immutable so replacement is creation.
<
re.matches("I am a string") //-->True
var s="I am a string thing"
Line 2,960 ⟶ 3,086:
re.search(s,True); // using .matched clears it
m:=re.matched[1];
s.replace(m,"FOO"); // -->"I am a FOO thing"</
Using a mutable byte bucket:
<
re.search(s,True);
p,n:=re.matched[0];
s[p,n]="FOO";
s.text //-->"I am a FOO thing"</
|