langref.org - ruby, csharp, cpp, fantom ...

View Category

Regex

Matching

Check if a string matches a regular expression

Display "ok" if "Hello" matches /[A-Z][a-z]+/

ruby

puts "ok" if ("Hello"=~/^[A-Z][a-z]+$/)

csharp

if (Regex.IsMatch("Hello", "[A-Z][a-z]+"))
{
Console.WriteLine("ok");
}

cpp

if ((gcnew Regex("[A-Z][a-z]+"))->IsMatch("Hello")) Console::WriteLine("ok");

if (Regex::IsMatch("Hello", "[A-Z][a-z]+")) Console::WriteLine("ok");

Regex^ rx = gcnew Regex("[A-Z][a-z]+");
if (rx->IsMatch("Hello")) Console::WriteLine("ok");

cmatch what;
if (regex_match("Hello", what, regex("[A-Z][a-z]+")))
cout << "ok" << endl;

fantom

if (Regex<|[A-Z][a-z]+|>.matches("Hello"))
echo("ok")

erlang

String = "Hello", Regexp = "[A-Z][a-z]+",
is_match(String, Regexp) andalso (begin io:format("ok~n"), true end).

case re:run("Hello", "[A-Z][a-z]+") of {match, _} -> ok end.

groovy

if ("Hello" =~ /[A-Z][a-z]+/) println 'ok'

if ("Hello".find(/[A-Z][a-z]+/)) println 'ok'

// with precompiled regex
def regex = ~/[A-Z][a-z]+/
if ("Hello".find(regex)) println 'ok'

// with precompiled regex
def regex = ~/[A-Z][a-z]+/
if ("Hello".matches(regex)) println 'ok'

if ("Hello".matches("[A-Z][a-z]+")) println 'ok'

haskell

import Text.Regex.Posix
main = if "Hello" =~ "[A-Z][a-z]+" then putStrLn "OK" else return ()

Check if a string matches with groups

Display "two" if "one two three" matches /one (.*) three/

ruby

puts $1 if "one two three"=~/^one (.*) three$/

csharp

using System;
using System.Text.RegularExpressions;

public class RegexBackReference {
public static void Main() {
var oneTwoThree = "one two three";
var pattern = "one (.*) three";

Match match = Regex.Match(oneTwoThree, pattern);

// group 0 is the entire match. 1 is the first backreference
Console.WriteLine(match.Groups[1]);
}
}

cpp

Match^ match = Regex::Match("one two three", "one (.*) three");
if (match->Success) Console::WriteLine("{0}", match->Groups[1]->Captures[0]);

cmatch what;
if (regex_match("one two three", what, regex("one (.*) three")))
cout << what[1] << endl;

fantom

m := Regex<|one (.*) three|>.matcher("one two three")
if (m.matches)
echo("${m.group(1)}")

erlang

case re:run("one two three", "one (.*) three", [{capture, [1], list}]) of {match, Res} -> hd(Res) end.

groovy

matcher = ("one two three" =~ /one (.*) three/)
if (matcher) println matcher[0][1]

match = "one two three".find("one (.*) three") { it[1] }
if (match) println match

haskell

import Text.Regex
main = case matchRegex (mkRegex "one (.*) three") "one two three" of
Nothing -> return ()
Just (x:_) -> putStrLn x

Searching

Check if a string contains a match to a regular expression

Display "ok" if "abc 123 @#$" matches /\d+/

ruby

puts "ok" if (text=~/\d+/)

csharp

if(System.Text.RegularExpressions.Regex.IsMatch("abc 123 @#$",@"\d+")){
Console.WriteLine("ok");
}

cpp

if (Regex::IsMatch("abc 123 @#$", "\\d+")) Console::WriteLine("ok");

fantom

m := Regex<|\d+|>.matcher("abc 123 @#\$")
if (m.find)
echo("ok")

erlang

% Erlang uses 'egrep'-compatible regular expressions, so shortcuts like '\d' not supported
String = "abc 123 @#$", Regexp = "[0-9]+",
is_match(String, Regexp) andalso (begin io:format("ok~n"), true end).

case re:run("abc 123 @#$", "\\d+") of {match, _} -> ok end.

groovy

if ('abc 123 @#$' =~ /\d+/) println 'ok'

if ('abc 123 @#$'.find(/\d+/)) println 'ok'

haskell

import Text.Regex
main = case matchRegex (mkRegex "\d+") "abc 123 @#$" of
Nothing -> putStrLn "not ok"
Just _ -> putStrLn "ok"

Loop through a string matching a regex and performing an action for each match

Create a list [fish1,cow3,boat4] when matching "(fish):1 sausage (cow):3 tree (boat):4" with regex /$(\w+)$:(\d+)/

ruby

list = text.scan(/$(\w+)$:(\d+)/).collect{|x| x.join}

list=[]
text.scan(/$(\w+)$:(\d+)/) {
list << $1+$2
}

csharp

using System;
using System.Collections.Generic;
using System.Text.RegularExpressions;

public static class extensions {
public static IList<string> Map(this string me, string pattern, Func<Match, string> action){
IList<string> matches = new List<string>();
foreach (Match match in Regex.Matches(me,pattern)){
matches.Add(action(match));
}
return matches;
}
}

class Test
{
static void Main()
{
IList<string> list = "(fish):1 sausage (cow):3 tree (boat):4".Map(@"$(\w+)$:(\d+)", (m) => {return m.Groups[1].Value + m.Groups[2].Value;});
}
}

cpp

Match^ match = Regex::Match("(fish):1 sausage (cow):3 tree (boat):4", "\$(\\w+)\$:(\\d+)");

while (match->Success)
{
list->Add(match->Groups[1]->Captures[0]->ToString() + match->Groups[2]->Captures[0]->ToString());
match = match->NextMatch();
}

fantom

m := Regex<|$(\w+)$:(\d+)|>.matcher(s)
list := Str[,]
while (m.find) { list.add("${m.group(1)}${m.group(2)}") }

erlang

solve(S) ->
R = "\$(\\w+?)\$:(\\d+)",
{match, M} = re:run(S,R, [global, {capture, all_but_first, list}]),
[ A++N || [A, N] <- M].

groovy

list = (text =~ /$(\w+)$:(\d+)/).collect{ it[1] + it[2] }

list = []
text.eachMatch(/$(\w+)$:(\d+)/){
list << it[1] + it[2]
}

list = []
text.eachMatch(/$(\w+)$:(\d+)/){ m, name, number ->
list << "$name$number"
}

list = (text =~ /$(\w+)$:(\d+)/).collect{ all, name, num -> "$name$num" }

list = text.findAll(regex){ _, name, num -> "$name$num" }

list = text.findAll(regex){ it[1] + it[2] }

haskell

import Text.Regex

getParenNum s = case matchRegexAll re s of
Nothing -> []
Just (_,_,after,[word,num]) -> (word ++ num):getParenNum after where
re = mkRegex "\$(\\w+)\$:([[:digit:]]+)"

main = putStrLn (show (getParenNum "(fish):1 sausage (cow):3 tree (boat):4"))

Replacing

Replace the first regex match in a string with a static string

Transform "Red Green Blue" into "R*d Green Blue" by replacing /e/ with "*"

ruby

p "Red Green Blue".sub(/e/,'*')

cpp

String^ Replaced = (gcnew Regex("e"))->Replace("Red Green Blue", "*", 1);

fantom

replaced := Regex<|e|>.split("Red Green Blue",2).join("*")

erlang

{ok, Replaced, _} = regexp:sub("Red Green Blue", "e", "*"),

re:replace("Red Green Blue", "e", "*", [{return, list}]).

groovy

replaced = "Red Green Blue".replaceFirst("e", "*")

Replace all regex matches in a string with a static string

Transform "She sells sea shells" into "She X X shells" by replacing /se\w+/ with "X"

ruby

replaced = text.gsub(/se\w+/,"X")

csharp

using System.Text.RegularExpressions;

class SolutionXX
{
static void Main()
{
string text = "She sells sea shells";
string result = Regex.Replace(text, @"se\w+", "X");
}
}

cpp

String^ Replaced = (gcnew Regex("se\\w+"))->Replace("She sells sea shells", "X");

String^ Replaced = Regex::Replace("She sells sea shells", "se\\w+", "X");

fantom

replaced := Regex<|se\w+|>.split("She sells sea shells").join("X")

erlang

% Erlang uses 'egrep'-compatible regular expressions, so shortcuts like '\w' not supported
{ok, Replaced, _} = regexp:gsub("She sells sea shells", "se[A-Za-z0-9_]+", "X"),

re:replace("She sells sea shells", "se\\w+", "X", [global, {return, list}]).

groovy

replaced = text.replaceAll(/se\w+/,"X")

Replace all regex matches in a string with a dynamic string

Transform "The {Quick} Brown {Fox}" into "The kciuQ Brown xoF" by reversing words in braces using the regex /\{(\w+)\}/.

ruby

"The {Quick} Brown {Fox}".gsub(/\{(\w+)\}/) {|s| s[1..-2].reverse }

cpp

String^ Replaced = (gcnew Regex("{(\\w+)}"))->Replace("The {Quick} Brown {Fox}", gcnew MatchEvaluator(&RegRep::RepGroup));

String^ Replaced = Regex::Replace("The {Quick} Brown {Fox}", "{(\\w+)}", gcnew MatchEvaluator(&RegRep::RepGroup));

fantom

s := "The {Quick} Brown {Fox}"
m := Regex<|\{(\w+)\}|>.matcher(s)
buf := StrBuf(s.size)
last := 0
while (m.find)
{
buf.add(s[last..m.start-1]).add(m.group(1).reverse)
last = m.end
}
buf.add(s[last..-1])
replaced := buf.toStr

erlang

% Erlang regular expressions lack both group capture and backreferences, thus this problem is not directly
% solvable. Presented solution is close, but not on-spec

String = "The {Quick} Brown {Fox}",
{match, FieldList} = regexp:matches(String, "\{([A-Za-z0-9_]+)\}"),

NewString = lists:foldl(fun ({Start, Length}, S) -> replstr(S, lists:reverse(string:substr(S, Start, Length)), Start) end, String, FieldList),

groovy

replaced = "The {Quick} Brown {Fox}".replaceAll(/\{(\w+)\}/, { full, word -> word.reverse() } )