Regular expressions: Difference between revisions

{{omit from|BASIC}}

{{omit from|Brlcad}}

{{omit from|GUISS}}

{{omit from|PARI/GP}}

:*   substitute part of a string using a regular expression

<br><br>

 

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

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

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

{{out}}

<pre>

hblahstblahk

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

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

 

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

Gives 101 dogs

</pre>

 

=={{header|Argile}}==

 

(: matching :)

uninit regex

 

 

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

$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

 

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

 

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

 

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

"This is even another string"<br>

"This is even ANOTHER string"<br>

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

 

 

 

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

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

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

</pre>

 

 

 

 

 

 

Or...

 

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

"Maple is Canadian"</pre>

 

The in-notebook output, in order:

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

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

 

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

 

string = re.sub(" a ", " another ", 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.

 

{{out}}

 

===testing===

$string="I am a string"

say 'The string is:' $string

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

{{out}}

<pre>

 

===substitution &nbsp; (destructive)===

$string = "I am a string"

old = " a "

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

say 'The changed string is:' $string

{{out}}

<pre>

 

===substitution &nbsp; (non-destructive)===

$string = "I am a string"

old = " a "

say 'The original string is:' $string

say 'The changed string is:' $string2

{{out}}

<pre>

 

===test and substitute===

$string = "I am a string"

old = " am "

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

end

{{out}}

<pre>

 

=={{header|Ring}}==

# Project : Regular expressions

 

text = left(text,i - 1) + "was" + substr(text,i + 2)

see "replace 'am' with 'was' = " + text + nl

Output:

<pre>

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

{{out}}

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

=={{header|Rust}}==

Note that <code>Regex::new</code> checks for a valid regex and thus returns a <code>Result<Regex, Error></code>.

 

fn main() {

 

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

#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

while (var m = str=~/(\w+):(\S+)/g) {

say "#{m[0]} -> #{m[1]}";

 

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

 

{{works with|GNU Smalltalk}}

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

s := 'this is a matching string'.

].

 

 

{{works with|Pharo}}

|re s s1|

re := 'm[a-z]+ing' asRegex.

s1 := re copy: s replacingMatchesWith: 'modified'.

 

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

See '''[http://www.stata.com/help.cgi?regexm regexm]''', '''regexr''' and '''regexs''' in Stata help.

 

 

* is there a vowel?

 

* replace the first vowel with "?"

=={{header|Swift}}==

 

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

 

===NSRegularExpression===

Test

 

if let regex = NSRegularExpression(pattern: "string$", options: nil, error: nil) {

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"

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

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)

 

How it works is that the body of the <code>coll</code> uses a double-variable match:

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

 

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

{{works with|bash}}

{{works with|ksh}}

if [[ $s =~ str..g$ ]]; then

echo "the string ends with 'str..g'"

 

===Replacing===

Given these values

re='o.*l'

 

{{works with|ksh}}

Can use regular expressions in parameter expansion

 

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

 

=={{header|Vala}}==

void main(){

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

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

}

 

{{out}}

=={{header|VBScript}}==

Replace white spaces with line breaks.

Set regex = New RegExp

regex.Global = True

Else

WScript.StdOut.Write "No matching pattern"

{{in}}

<pre>I need more coffee!!!</pre>

 

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,

ca -l mod rosettacoderegex.w68

That's it. The resulting binary will print

 

=={{header|zkl}}==

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"

re.search(s,True); // using .matched clears it

m:=re.matched[1];

 

Using a mutable byte bucket:

re.search(s,True);

p,n:=re.matched[0];

s[p,n]="FOO";