Clojure Core

Namespaces

clojure
- core
  - protocols
- data
- inspector
- java
  - browse
  - browse-ui
  - io
  - javadoc
  - shell
- main
- pprint
- reflect
- repl
- set
- stacktrace
- string
- template
- test
  - junit
  - tap
- walk
- xml
- zip

doc source examples comments

1.3.0

replace

clojure.string

(replace s match replacement)

Replaces all instance of match with replacement in s.

match/replacement can be:

string / string
char / char
pattern / (string or function of match).

See also replace-first.

© Rich Hickey. All rights reserved. Eclipse Public License 1.0

4 Examples top

link | changes
```
user=> (clojure.string/replace "The color is red" #"red" "blue")
"The color is blue"
```
user=> (clojure.string/replace "The color is red" #"red" "blue") "The color is blue"
link | changes
```
user=> (clojure.string/replace "The color is red." #"[aeiou]"  #(str %1 %1))
"Thee cooloor iis reed."
```
user=> (clojure.string/replace "The color is red." #"[aeiou]" #(str %1 %1)) "Thee cooloor iis reed."
link | changes
```
;; Note: When replace-first or replace have a regex pattern as their
;; match argument, dollar sign ($) and backslash (\) characters in
;; the replacement string are treated specially.

;; Example: first substring that the pattern matches is "fodder", with
;; (o+) matching "o" and (\S+) matching "dder".  Replacement string
;; says to replace the entire match "fodder" with $2, the string
;; matched by the second parenthesized group, "dder", followed by $1,
;; "o".
user=> (str/replace "fabulous fodder foo food" #"f(o+)(\S+)" "$2$1")
"fabulous ddero oo doo"

;; To avoid this special treatment of $ and \, you must escape them with
;; \.  Because it is in a Clojure string, to get one \ we must escape
;; *that* with its own \.
user=> (str/replace "fabulous fodder foo food" #"f(o+)(\S+)" "\\$2\\$1")
"fabulous $2$1 $2$1 $2$1"

;; To ensure the replacement is treated literally, call
;; java.util.regex.Matcher/quoteReplacement on it.  A shorter name
;; like re-qr can be handy.
user=> (import '(java.util.regex Matcher))
java.util.regex.Matcher

user=> (defn re-qr [replacement]
         (Matcher/quoteReplacement replacement))
#'user/re-qr

user=> (str/replace "fabulous fodder foo food" #"f(o+)(\S+)" (re-qr "$2$1"))
"fabulous $2$1 $2$1 $2$1"
```
;; Note: When replace-first or replace have a regex pattern as their ;; match argument, dollar sign ($) and backslash (\) characters in ;; the replacement string are treated specially. ;; Example: first substring that the pattern matches is "fodder", with ;; (o+) matching "o" and (\S+) matching "dder". Replacement string ;; says to replace the entire match "fodder" with $2, the string ;; matched by the second parenthesized group, "dder", followed by $1, ;; "o". user=> (str/replace "fabulous fodder foo food" #"f(o+)(\S+)" "$2$1") "fabulous ddero oo doo" ;; To avoid this special treatment of $ and \, you must escape them with ;; \. Because it is in a Clojure string, to get one \ we must escape ;; *that* with its own \. user=> (str/replace "fabulous fodder foo food" #"f(o+)(\S+)" "\\$2\\$1") "fabulous $2$1 $2$1 $2$1" ;; To ensure the replacement is treated literally, call ;; java.util.regex.Matcher/quoteReplacement on it. A shorter name ;; like re-qr can be handy. user=> (import '(java.util.regex Matcher)) java.util.regex.Matcher user=> (defn re-qr [replacement] (Matcher/quoteReplacement replacement)) #'user/re-qr user=> (str/replace "fabulous fodder foo food" #"f(o+)(\S+)" (re-qr "$2$1")) "fabulous $2$1 $2$1 $2$1"
link | changes
```
;; replaces all a's with 1 and all b's with 2
user=>(clojure.string/replace "a b a" #"a|b" {"a" "1" "b" "2"})
"1 2 1"
```
;; replaces all a's with 1 and all b's with 2 user=>(clojure.string/replace "a b a" #"a|b" {"a" "1" "b" "2"}) "1 2 1"

Log in to add / edit an example.

See Also top

0
clojure.core/subs
Returns the substring of s beginning at start inclusive, and ending
0
clojure.string/split
Splits string on a regular expression. Optional argument limit is
0
clojure.string/replace-first
Replaces the first instance of match with replacement in s. match

Log in to add a see also.

Source clojure/string.clj:63 top

(defn ^String replace
  "Replaces all instance of match with replacement in s.

   match/replacement can be:

   string / string
   char / char
   pattern / (string or function of match).

   See also replace-first."
  {:added "1.2"}
  [^CharSequence s match replacement]
  (let [s (.toString s)]
    (cond 
     (instance? Character match) (.replace s ^Character match ^Character replacement)
     (instance? CharSequence match) (.replace s ^CharSequence match ^CharSequence replacement)
     (instance? Pattern match) (if (instance? CharSequence replacement)
                                 (.replaceAll (re-matcher ^Pattern match s)
                                              (.toString ^CharSequence replacement))
                                 (replace-by s match replacement))
     :else (throw (IllegalArgumentException. (str "Invalid match arg: " match))))))

© Rich Hickey. All rights reserved. Eclipse Public License 1.0

Vars in clojure.string/replace:

Used in 0 other vars

Comments top

1 comment(s) for replace.

TejasBhatt

link

How can i replace "." with #"\s"

Log in to add a comment.