Regular expressions: Difference between revisions

{{trans|Python}}

I re:‘string$’.search(string)

string = string.replace(re:‘ a ’, ‘ another ’)

{{out}}

=={{header|8th}}==

"haystack" /a./ r:match . cr

"haystack" /a./ "blah" s:replace! . cr

{{out}}

<pre>

=={{header|ABAP}}==

DATA: text TYPE string VALUE 'This is a Test'.

cl_demo_output=>write( text ).

cl_demo_output=>display( ).

Output:

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

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

Put_Line(Str);

{{out}}

<!-- {{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: #

{{out}}

<pre>

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

{{out}}

<pre>

=={{header|Amazing Hopper}}==

task 1: match a string against a regular expression (Hopper use POSIX):

#include <hopper.h>

exit(0)

{{out}}

<pre>

</pre>

Task 2: Hopper does not substitute using regular expressions, but using proper functions.

#include <hopper.h>

exit(0)

{{out}}

<pre>

=={{header|AppleScript}}==

{{libheader|Satimage.osax}}

find text ".*string$" in "I am a string" with regexp

on error message

on error message

return message

----

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.

'''do shell script:'''

try

set output to (do shell script "echo 'I am a string' | egrep -o '\\S+$'")

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

'''ASObjC''' uses [http://userguide.icu-project.org/strings/regexp ICU regex]:

use framework "Foundation"

end if

As an alternative to the NSString regex options used above, there's also a dedicated NSRegularExpression class:

use framework "Foundation"

end if

{{out}}

=={{header|Argile}}==

(: matching :)

uninit regex

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

=={{header|Arturo}}==

if contains? s {/string$/} -> print "yes, it ends with 'string'"

replace 's {/[as]/} "x"

{{out}}

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

{{out}}

<pre>

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

{{out}}

<pre>789/357

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;

===Alternative using GLib===

The task is a bit easier with GLib's Perl-compatible regular expression functionality.

{{libheader|GLib}}

#include <glib.h>

regex_replace_demo();

return 0;

{{out}}

=={{header|C sharp}}==

using System.Text.RegularExpressions;

Console.WriteLine(str);

}

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

Standards earlier than C++11 can make use of Boost's Regex library via boost/regex.hpp

#include <string>

#include <iterator>

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

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

{{libheader| System.RegularExpressions}}

Sample program that uses a regex, for translate a line of code in cpp to pascal.

program Regular_expressions;

end.

{{out}}

=={{header|Elixir}}==

Elixir allows pattern matching using the <code>~r</code> sigil.

str = "This is a string"

if str =~ ~r/string$/, do: IO.inspect "str ends with 'string'"

A number of modifiers can be appended to the regular expression; <code>~r/pattern/i</code>, for instance, toggles case insensitivity.

str =~ ~r/this/ # => false

str =~ ~r/this/i # => true

Both <code>Regex</code> and <code>String</code> have a <code>replace</code> function.

str1 = ~r/a/ |> Regex.replace(str,"another")

str2 = str1 |> String.replace(~r/another/,"even another")

<code>Regex.replace</code> allows for a function to be used as a replacement value. A function can modify the found pattern.

str3 = ~r/another/ |> Regex.replace(str2, fn x -> "#{String.upcase(x)}" end)

{{out}}

=={{header|Emacs Lisp}}==

(when (string-match-p "string$" string)

(message "Ends with 'string'"))

{{out}}

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

IN: rosetta-code.regexp

"1001" R/ 10+/ re-contains? . ! Does the string contain the regexp anywhere?

{{out}}

<pre>

{{libheader|Forth Foundation Library}}

Test/Match

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

[ELSE]

.( No match.) cr

=={{header|FreeBASIC}}==

Dim As String text = "I am a text"

If Right(text, 4) = "text" Then

Print "replace 'am' with 'was' = " + text

Sleep

{{out}}

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

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

'''[https://gambas-playground.proko.eu/?gist=5a2a1052f8dff12596fa7f45242d25a9 Click this link to run this code]'''

Dim sString As String = "Hello world!"

Print sString

Output:

<pre>

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

/* Regular expressions, in Genie */

except err:RegexError

{{out}}

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

{{out}}

Replacement Solution (String.replaceAll()):

{{out}}

Reusable Replacement Solution (Matcher.replaceAll()):

println (ck.replaceAll("CHUCK"))

println (ck.replaceAll("wind"))

println (ck.replaceAll("man"))

println (ck.replaceAll("work"))

{{out}}

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

Additionally, there is a regular expression pattern compiler 'RePat' and other supporting functions and variables.

s := "A simple string"

end

{{libheader|Icon Programming Library}}

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

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

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

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

// matches[1] == "world"

Substitute

// Perform a string replacement

// newSubject == "Replaced!"

=={{header|jq}}==

'''Test''':

yields: true

'''Substitutution''':

yields: "I am another string"

'''Substitution using capture''':

yields: "a-bc"

=={{header|Jsish}}==

var re = /s[ai]mple/;

var replaced = sentence.replace(re, "different");

{{out}}

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

fun main(args: Array<String>) {

val s2 = s1.replace(r2, s3)

if (s2 != s1) println("`$s2` replaces `$r2` with `$s3`")

{{out}}

To match a string, ...

Or...

{{works with|langur|0.10}}

Prior to 0.10, multi-variable declaration/assignment would use parentheses around variable names and values.

Or...

case re/abc/: ...

...

Or...

case "somestring": ...

...

Substitution does not alter the original string.

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

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

sub, num_matches = test:gsub(pattern, "Hello, %1!")

=={{header|M2000 Interpreter}}==

Enumerators for some COM objects are number of function -4&, we can use this in place of string for the name of property.

Module CheckIt {

declare global ObjRegEx "VBscript.RegExp"

}

Internal

=={{header|M4}}==

{{out}}

=={{header|Maple}}==

StringTools:-RegMatch("^ab+bc$", "abbbbc");

StringTools:-RegMatch("^ab+bc$", "abbbbcx");

StringTools:-RegSub("a([bc]*)(c*d)", "abcd", "&-\\1-\\2");

{{Out|Output}}

<pre>true

=={{header|Mathematica}}/{{header|Wolfram Language}}==

The in-notebook output, in order:

<pre>{18374}

=={{header|MAXScript}}==

samples = #("Some string 123","Example text 123","string",\

"ThisString Will Not Match","A123,333,string","123451")

)

)

{{Out}}

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

{{out}}

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

{{out}}

<pre>

=={{header|NewLISP}}==

=={{header|Nim}}==

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

; matching:

(define regex (string->regex "m/aa(bb|cc)dd/"))

(print (regex "aabcddx")) ; => false

=={{header|ooRexx}}==

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

::requires "rxregexp.cls"

{{out}}

<pre>

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

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

{{out}}

<pre>

=={{header|PHP}}==

{{works with|PHP|5.2.0}}

# Test

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

# Replace

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

{{out}}

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

{{out}}

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

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)

{{out}}

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