langref.org - ruby, java, perl, groovy ... - Regex

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/,'*')

java

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

perl

$text =~s/e/*/;

groovy

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

scala

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

python

print re.sub(r'e', '*', 'Red Green Blue', 1)

cpp

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

fsharp

let replaced = ((new Regex("e")).Replace("Red Green Blue", "*", 1))
printfn "%s" replaced

erlang

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

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

ocaml

let replaced = Str.replace_first (Str.regexp "e") "*" "Red Green Blue" in
print_endline replaced ;;

php

echo preg_replace('/e/', '*', "Red Green Blue", 1);

clojure

(.replaceFirst (re-matcher #"e" "Red Green Blue") "*")

fantom

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

go

i := 0
f := func (in string) (out string) {
i++
if i == 1 {
return "*"
}
return in
}

re, _ := regexp.Compile("e")
s := re.ReplaceAllStringFunc("Red Green Blue", f)
fmt.Println(s)

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

java

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

perl

$text = "She sells sea shells";
$text =~ s/se\w+/X/g;

groovy

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

scala

val replaced = "She sells sea shells".replaceAll("se\\w+", "X")

python

transformed = re.sub(r'se\w+', 'X', 'She sells sea shells')

cpp

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

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

fsharp

let replaced = ((new Regex("se\\w+")).Replace("She sells sea shells", "X"))
printfn "%s" replaced

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}]).

ocaml

let s = "She sells sea shells" in
Str.global_replace (Str.regexp "se[^ \\t\\n]*") "X" s

csharp

using System.Text.RegularExpressions;

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

php

echo preg_replace('/se\w+/', 'X', 'She sells sea shells');

clojure

(.replaceAll (re-matcher #"se\w+" "She sells sea shells") "X")

fantom

replaced := Regex<|se\w+|>.split("She sells sea shells").join("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 }

java

Matcher m = Pattern.compile("\\{(\\w+)\\}").matcher("The {Quick} Brown {Fox}");
StringBuffer sb = new StringBuffer(32), rsb = new StringBuffer(8);

while (m.find())
{
rsb.replace(0, rsb.length(), m.group(1)); rsb.reverse(); m.appendReplacement(sb, rsb.toString());
}
m.appendTail(sb);

perl

$text = "The {Quick} Brown {Fox}";
$text =~ s/\{(\w+)\}/reverse($1)/ge;

groovy

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

scala

val m = Pattern.compile("\\{(\\w+)\\}").matcher("The {Quick} Brown {Fox}")
val sb = new StringBuffer(32) ; val rsb = new StringBuffer(8)

while (m.find) { rsb.replace(0, rsb.length, m.group(1)) ; m.appendReplacement(sb, rsb.reverse.toString) }
m.appendTail(sb)

python

transformed = re.sub(r'\{(\w+)\}',
lambda match: match.group(1)[::-1],
'The {Quick} Brown {Fox}')

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

fsharp

open System
open System.Text.RegularExpressions
let reverseMatch (m:Match) =
String(m.Groups.[1].Value.ToCharArray() |> Array.rev)
let output = Regex.Replace("The {Quick} Brown {Fox}", @"\{(\w+)\}", reverseMatch)

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

ocaml

let s = "The {Quick} Brown {Fox}" in
let r = Str.regexp "{\$[^ \\t\\n]*\$}" in
Str.global_substitute r (fun m -> string_rev (Str.matched_group 1 m)) s

php

// We have to use the e-modifier
preg_replace("/\{(\w+)\}/e", "''.strrev('\\1').''", "The {Quick} Brown {Fox}");

clojure

(def *string* "The {Quick} Brown {Fox}")
(def *regex* (re-pattern #"\{(\w+)\}"))

(println
(loop [result ""
src *string*
replace-strs (re-seq *regex* *string*)]
(if (empty? src)
result
(let [[match replacement] (first replace-strs)]
(if (= (first src) (first match))
; At the beginning of a sequence that should be replaced.
; Do replacement of a single match
(recur (str result (apply str (reverse replacement)))
(drop (count match) src)
(rest replace-strs))
; else, just copy one char from the source to the result
(recur (str result (first src))
(rest src)
replace-strs))))))

(clojure.string/replace "The {Quick} Brown {Fox}"
#"\{(\w+)\}"
(fn [[_ word]] (apply str (reverse word))))

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