Regular expressions: Difference between revisions

 

 

=={{header|Ada}}==

 

procedure Regex is

Str := Str(Str'First .. First-1) & "pattern" & Str(Last+1 .. Str'Last);

Put_Line(Str);

 

<pre><I>

<love>

<matching>

I love pattern matching!</pre>

 

=={{header|ALGOL 68}}==

 

<!-- {{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";

# Replace: #

 

<pre>

Ends with "string"

</pre>

 

But it can also be used for outputting (and transputting) the original data.

 

{{works with|ALGOL 68G|Any - tested with release mk15-0.8b.fc9.i386}}

 

FILE file; STRING book; associate(file, book);

on value error(file, (REF FILE f)BOOL: stop);

print(("Dalmatians: ", dalmatians, new line));

count OF dalmatians +:=1;

<pre>

Dalmatians: +100 +2

Gives 101 dogs

</pre>

 

=={{header|Argile}}==

 

(: matching :)

uninit regex

 

 

(note that it needs to be compiled with argrt library)

 

<pre>

string matches

$0m3 4ll0c4t3d $tr1ng

</pre>

 

=={{header|AutoHotkey}}==

 

=={{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

As shorthand, a regular expression in the condition part fires if it matches an input line:

def

DeF

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

This variant matches one or more uppercase letters in one round:

abCDefGH

 

Regular expression negation can be achieved by combining the regular expression binding operator with a logical not operator, as follows:

{{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

ENDIF

 

<pre>

<I>

 

=={{header|Bracmat}}==

 

List all rational numbers smaller then 7 hidden in the string "fgsakg789/35768685432fkgha"

<pre>789/357

789/3576

Test

 

 

true? str.match(/string$/)

false? str.match(/^You/)

{ p "Does not start with 'You'" }

 

Substitute

 

 

str2 = str.sub(/ a /, " another ")

 

p str # prints "I Am Another string"

 

=={{header|C}}==

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>

return 0;

 

=={{header|C++}}==

 

#include <string>

#include <iterator>

 

int main()

{

std::string s = "Hi, I am a string";

 

// match the complete string

std::cout << "The string matches.\n";

else

 

// match a substring

{

std::cout << "Matched " << match.length()

// 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)

;; substitute

(println (clojure.string/replace s " a " " another "))

 

=={{header|Common Lisp}}==

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 )

 

Substitute

 

(string (cl-ppcre:regex-replace " a " string " another ")))

 

Test and Substitute

 

(multiple-value-bind (string matchp)

(cl-ppcre:regex-replace "\\bam\\b" string "was")

(when matchp

 

===CLISP regexp engine===

{{works with|CLISP}}

[[Clisp]] comes with [http://clisp.org/impnotes/regexp-mod.html built-in regexp matcher]. On a Clisp prompt:

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")

 

=={{header|D}}==

import std.stdio, std.regex;

 

 

// Test.

"Ends with 'string'.".writeln;

 

// Substitute.

s.replace(" a ".regex, " another ").writeln;

{{out}}

<pre>Ends with 'string'.

 

=={{header|Dart}}==

 

String capitalize(Match m) => '${m[0].substring(0, m[0].length-1).toUpperCase()}';

print(hello);

print(hellomodified);

{{out}}

<pre>hello hello! world world!

hello HELLO world WORLD</pre>

 

=={{header|Erlang}}==

String = "This is a string",

case re:run(String, "string$") of

String = "This is a string",

NewString = re:replace(String, " a ", " another ", [{return, list}]),

 

=={{header|F_Sharp|F#}}==

{{trans|C#}}

open System.Text.RegularExpressions

 

let rstr = Regex(" a ").Replace(str, " another ")

Console.WriteLine(rstr)

 

=={{header|Forth}}==

{{libheader|Forth Foundation Library}}

Test/Match

 

\ Create a regular expression variable 'exp' in the dictionary

[ELSE]

.( No match.) cr

 

 

=={{header|Frink}}==

Pattern matching:

line = "My name is Inigo Montoya."

 

println["Last name is: $last"]

}

 

Replacement: (Replaces in the variable <code>line</code>)

line =~ %s/Frank/Frink/g

 

=={{header|GeneXus}}==

<br />

Replacement:<br />

Check match:

// The string ends with "regex"

Split RegEx:

Matches:

For &RegExMatch In &RegExMatchCollection

&FullMatch = &RegExMatch.Value // &FullMatch contains the full pattern match: "pattern"

// &matchVarchar contains group matches: "pa", "ern"

EndFor

Flags: <br />

s - Dot matches all (including newline) <br />

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

=={{header|Go}}==

import "fmt"

import "regexp"

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?"

 

println ("'${woodchuck}' ${wwNotMatches ? 'does not' : 'does'} match '${woodRE}' exactly")

 

<pre>=== Regular-expression String syntax (/string/)===

[woodRE:[Ww]o\w+d, piperRE:[Pp]\w+r]

 

Replacement Solution (String.replaceAll()):

 

<pre>How much wood would a woodCHUCK CHUCK if a woodCHUCK could CHUCK wood?</pre>

 

Reusable Replacement Solution (Matcher.replaceAll()):

println (ck.replaceAll("CHUCK"))

println (ck.replaceAll("wind"))

println (ck.replaceAll("man"))

println (ck.replaceAll("work"))

 

<pre>How much wood would a woodCHUCK CHUCK if a woodCHUCK could CHUCK wood?

How much wood would a woodwind wind if a woodwind could wind wood?

=={{header|Haskell}}==

Test

 

str = "I am a string"

case matchRegex (mkRegex ".*string$") str of

Just _ -> putStrLn $ "ends with 'string'"

 

Substitute

 

orig = "I am the original string"

result = subRegex (mkRegex "original") orig "modified"

 

=={{header|HicEst}}==

REAL, PARAMETER :: Regex=128, Count=256

 

 

vocals_changed = EDIT(Text=string, Option=Regex, Right="[aeiou]", RePLaceby='**', DO=LEN(string) ) ! changes 11

 

=={{header|Icon}} and {{header|Unicon}}==

 

 

s := "A simple string"

end

 

{{libheader|Icon Programming Library}}

[http://www.cs.arizona.edu/icon/library/procs/regexp.htm See regexp].

 

"A simple replacement"</pre>

 

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.";

 

=={{header|J}}==

J's regex support is built on top of PCRE.

 

 

Matching:

 

Substitution:

 

 

=={{header|Java}}==

{{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");

 

=={{header|JavaScript}}==

Test/Match

 

// Two different ways to create the RegExp object

var re_PatternToMatch = /Hello (World)/i; // creates a RegExp literal with case-insensitivity

var re_PatternToMatch2 = new RegExp("Hello (World)", "i");

// matches[0] == "Hello world"

// matches[1] == "world"

 

Substitute

 

// Perform a string replacement

// newSubject == "Replaced!"

 

=={{header|Julia}}==

{{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'")

To perform replacements:

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|Lasso}}==

Lasso has built in support for regular expressions using ICU regexps.

My name is: Hippo, Campus

')

#regexp -> reset(-input = #mytext)

'<br />'

<pre>Rosetta

Campus

 

=={{header|Lua}}==

 

 

=={{header|M4}}==

 

<pre>

5

a not b ot c

</pre>

The in-notebook output, in order:

<pre>

</pre>

 

=={{header|MIRC Scripting Language}}==

var %string = This is a string

var %re = string$

%re = \b(another)\b

echo -a Result 2: $regsubex(%string,%re,yet \1)

 

<pre>

Ends with string.

 

=={{header|MUMPS}}==

NEW HI,W,PATTERN,BOOLEAN

SET HI="Hello, world!",W="world"

SET BOOLEAN=$FIND(HI,W)

IF BOOLEAN>0 WRITE $PIECE(HI,W,1)_"string"_$PIECE(HI,W,2)

Usage:<pre>

USER>D REGEXP^ROSETTA

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols nobinary

 

 

return

<pre>

String "Fee, fie, foe, fum, I smell the blood of an Englishman" matches pattern "(?i)f.e.*?": true

</pre>

 

 

 

var s = "This is a string"

 

s = s.replace(re"\ a\ ", " another ")

 

=={{header|Objeck}}==

use RegEx;

 

}

}

 

=={{header|Objective-C}}==

{{works with|Mac OS X|10.4+}}

{{works with|iOS|3.0+}}

NSString *regex = @".*string$";

 

if ([pred evaluateWithObject:str]) {

NSLog(@"ends with 'string'");

Unfortunately this method cannot find the location of the match or do substitution.

 

{{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])];

 

===NSRegularExpression===

{{works with|iOS|4.0+}}

Test

options:0

error:NULL];

].location != NSNotFound) {

NSLog(@"Ends with 'string'");

 

Loop through matches

options:0

range:NSMakeRange(0, [str length])

// 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

range:NSMakeRange(0, [orig length])

withTemplate:@"modified"];

 

=={{header|OCaml}}==

=== With the standard library ===

Test

let str = "I am a string";;

try

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;;

 

=== 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)

Printf.printf "Substitute: %s\n"

(Pcre.replace ~pat:"original" ~templ:"modified" "I am the original string")

 

=={{header|ooRexx}}==

/* Using the RxRegExp Regular Expression built-in utility class */

 

 

::requires "rxregexp.cls"

<pre>

String "Fee, fie, foe, fum, I smell the blood of an Englishman" matches pattern "[Ff]?e": true

 

=={{header|Oxygene}}==

// Match and Replace part of a string using a Regular Expression

//

end.

Produces:

<pre>

 

=={{header|Oz}}==

[Regex] = {Module.link ['x-oz://contrib/regex']}

String = "This is a string"

{System.showInfo "Ends with string."}

end

=={{header|Pascal}}==

// Match and Replace part of a string using a Regular Expression

//

if r.Exec(myResult) then writeln(' contains ' + r.Match[0]);

end.

Produces:

<pre>

{{works with|Perl|5.8.8}}

Test

if ($string =~ /string$/) {

print "Ends with 'string'\n";

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"

 

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

 

 

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

# m = multi-line (the expression is run on each line individually)

 

 

Omission of the regular expression binding operators

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|PHP}}==

{{works with|PHP|5.2.0}}

# Test

if (preg_match('/string$/', $string))

# Replace

$string = preg_replace('/\ba\b/', 'another', $string);

 

<pre>Ends with 'string'

Foud 'a' and replaced it with 'another', resulting in this string: I am another string</pre>

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))

<pre>String "a7z" matches pattern "a[0-9]z"</pre>

===Using Pattern Matching===

(use (@A @N @Z)

(and

(match '(@A "<" @N ">" @Z) (chop String))

(format @N)

<pre>The number <8> is incremented</pre>

 

=={{header|PowerShell}}==

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, ]*"

EndIf

Debug ReplaceRegularExpression(2, String$, "char stuff")

 

=={{header|Python}}==

 

string = "This is a string"

 

print("Ends with string.")

 

 

=={{header|R}}==

First, define some strings.

text1 <- "this is a matching string"

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

 

 

(displayln (regexp-replace " a " s " another "))

 

=={{header|Raven}}==

 

 

Match:

 

 

Replace once:

 

 

Replace all:

 

 

Replace case insensitive:

 

 

Splitting:

 

 

=={{header|REBOL}}==

Title: "Regular Expression Matching"

URL: http://rosettacode.org/wiki/Regular_expression_matching

]

 

replace string " another " " a " ; Change string back.

 

<pre>Subject ends with 'string.'

 

 

=={{header|REXX}}==

Rexx does not directly support the use of regular expressions as part of the language.

<br>However, some rexx interpreters offer support for regular expressions via external function libraries or

<br><br>It is also possible to emulate regular expressions through appropriate coding techniques.

<br><br>All of the following REXX examples are modeled after the '''PERL''' examples.

 

The string is: I am a string

It ends with: string

It does not contain the word: ring

</pre>

$string = "I am a string"

old = " a "

new = " another "

$string = changestr(old,$string,new)

The original string is: I am a string

old word is: a

The changed string is: I am another string

</pre>

$string = "I am a string"

old = " a "

new = " another "

say 'The original string is:' $string

$string2 = changestr(old,$string,new)

say 'The original string is:' $string

say 'The changed string is:' $string2

The original string is: I am a string

old word is: a

The changed string is: I am another string

</pre>

$string = "I am a string"

old = " am "

new = " was "

say 'The original string is:' $string

 

do

$string = changestr(old,$string,new)

say 'I was able to find and replace ' old " with " new

end

The original string is: I am a string

old word is: am

I was able to find and replace am with was

</pre>

<br><br>

 

=={{header|Ruby}}==

Test

p "Ends with 'string'" if str =~ /string$/

 

Substitute

# Or:

str[/ a /] = ' another ' #=> "another"

 

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$

<pre>'I am a string' ends with 'string'

replace 'am' with 'was' = I was a string</pre>

 

=={{header|Sather}}==

Sather understands POSIX regular expressions.

 

-- we need to implement the substitution

regex_subst(re:REGEXP, s, sb:STR):STR is

#OUT + regex_subst(REGEXP::regexp("am +a +st", true), s, "get the ") + "\n";

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

 

Search and replace with string methods:

"99 bottles of beer" replace ("99", "98") // Single 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

 

Using pattern matching with regex:

for {

line <- """|99 bottles of beer on the wall

for {

matched <- "(\\w+)".r findAllIn "99 bottles of beer" matchData // matchData converts to an Iterator of Match

 

Replacing with regex:

 

=={{header|Shiny}}==

 

Match text:

say "Ends with 'string'"

 

Replace text:

=={{header|Sidef}}==

Simple matching:

if (str =~ /string$/) {

print "Ends with 'string'\n";

 

Global matching:

x:Foo

y:Bar

EOF

 

 

Substitutions:

 

# Substitute something mached by a regex

str = str.gsub(/(\w+)/, {|s1| 'x' * s1.len}); # globaly replace any word with 'xxx'

 

 

=={{header|Slate}}==

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} "

 

=={{header|Smalltalk}}==

 

re := Regex fromString: '[a-z]+ing'.

s := 'this is a matching string'.

].

 

 

 

=={{header|SNOBOL4}}==

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.

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):

 

 

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)

 

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.

{{works with|SML/NJ}}

Test

structure RE = RegExpFn (

structure P = AwkSyntax

in

print ("matched at position " ^ Int.toString pos ^ "\n")

 

=={{header|Tcl}}==

Test using <code>regexp</code>:

if {[regexp -- {string$} $theString]} {

puts "Ends with 'string'"

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>

 

=={{header|Toka}}==

Toka's regular expression library allows for matching, but does not yet provide for replacing elements within strings.

 

needs regex

 

#! try-regex will return a flag. -1 is TRUE, 0 is FALSE

expression test.1 2 match try-regex .

 

=={{header|TXR}}==

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)

 

 

 

===Search and replace: strip comments from C source===

 

Based on the technique of the previous example, here is a query for stripping C comments from a source file, replacing

 

@(coll :gap 0)@notcomment@{comment /[/][*].%[*][/]/}@(end)@tail

@(output)

@(rep)@notcomment @(end)@tail

 

===Regexes in TXR Lisp===

Parse regex at run time to abstract syntax:

 

 

Dynamically compile regex abstract syntax to regex object:

 

 

Search replace with <code>regsub</code>.

 

 

=={{header|Vala}}==

void main(){

string sentence = "This is a sample sentence.";

stdout.printf("Replaced sentence is: %s\n", sentence);

}

 

<pre>

"s[ai]mple" is in "This is a sample sentence."!

Replaced sentence is: This is a cat sentence.

</pre>

=={{header|Vedit macro language}}==

Vedit can perform searches and matching with either regular expressions, pattern matching codes or plain text. These examples use regular expressions.

 

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}}==

 

@a@<Compiler prelude@>

ca -l mod rosettacoderegex.w68

That's it. The resulting binary will print

 

=={{header|zkl}}==

re.matches("I am a string") //-->True

var s="I am a string thing"