clojure.core/re-find

View this page on ClojureDocs

Type: function Added: Clojure 1.0 Examples: 7 Runnable: 3

([m] [re s])

Returns the next regex match, if any, of string to pattern, using java.util.regex.Matcher.find(). Uses re-groups to return the groups.

Examples

by nipra on 2010-07-13 . May have evaluation errors. ▶

(def matcher (re-matcher #"\d+" "abc12345def")) #'user/matcher (re-find matcher) "12345" ;; If you only want the first match, it is shorter to call re-find with the ;; pattern and the string to search, rather than explicitly creating a matcher ;; as above. (re-find #"\d+" "abc12345def") "12345" ;; If you want all matches as a sequence, use re-seq. Creating a matcher ;; explicitly with re-matcher and passing it to re-find is only the best way ;; if you want to write a loop that iterates through all matches, and do not ;; want to use re-seq for some reason.

by OnesimusUnbound on 2011-08-03 . May have evaluation errors. ▶

;; re-find can be used to iterate through re matches in the string (def phone-number "672-345-456-3212") #'user/phone-number (def matcher (re-matcher #"\d+" phone-number)) #'user/matcher (re-find matcher) "672" (re-find matcher) "345" (re-find matcher) "456" (re-find matcher) "3212" ;; when there's no more valid matches, nil is returned (re-find matcher) nil

by jafingerhut on 2011-12-16 . May have evaluation errors. ▶

;; When there are parenthesized groups in the pattern and re-find ;; finds a match, it returns a vector. The first item is the part of ;; the string that matches the entire pattern, and each successive ;; item are the parts of the string that matched the 1st, 2nd, ;; etc. parenthesized groups. Groups are numbered by the order in ;; which their left parenthesis occurs in the string, from left to ;; right. (def line " RX packets:1871074138 errors:5 dropped:48 overruns:9") #'user/line (re-find #"(\S+):(\d+)" line) ["packets:1871074138" "packets" "1871074138"] ;; groups can nest (re-find #"(\S+:(\d+)) \S+:\d+" line) ["packets:1871074138 errors:5" "packets:1871074138" "1871074138"] ;; If there is no match, re-find always returns nil, whether there are ;; parenthesized groups or not. (re-find #"(\S+):(\d+)" ":2 numbers but not 1 word-and-colon: before") nil ;; A parenthesized group can have nil as its result if it is part of ;; an 'or' (separated by | in the regex), and another alternative is ;; the one that matches. (re-find #"(\D+)|(\d+)" "word then number 57") ["word then number " "word then number " nil] (re-find #"(\D+)|(\d+)" "57 number then word") ["57" nil "57"] ;; It is also possible for a group to match the empty string. (re-find #"(\d*)(\S)\S+" "lots o' digits 123456789") ["lots" "" "l"] ;; If you want to use parentheses to group a part of the regex, but ;; have no interest in capturing the string it matches, you can follow ;; the left paren with ?: to prevent capturing. (re-find #"(?:\S+):(\d+)" line) ["packets:1871074138" "1871074138"] ;; re-matches also behaves this way, and re-seq returns a sequence of ;; matches, where each one can be a vector like re-find returns.

by Claj on 2012-01-13 . May have evaluation errors. ▶

;;It's possible to get variables out of your string with regexp (re-find #"(\d\d\d) (USD)" "450 USD") ["450 USD" "450" "USD"] (nth *1 1) "450" ;;thanks kotarak @ stackoverflow.com for this one

by Pete Mancini on 2013-05-30 ▶

;; If your input has line delimiters you can switch on multiline with (?m) (def testcase "Line 1\nLine 2\nTarget Line\nLine 4\nNot a target line") (re-find #"(?im)^target.*$" testcase) "Target Line"

by jafingerhut on 2013-09-13 ▶

;; Note: See clojure.core/subs for discussion of behavior of substrings ;; holding onto references of the original strings, which can ;; significantly affect your memory usage in some cases.

by jgomo3 on 2020-08-22 ▶

;; Use it as a simple predicate based on regexp, ;; since it returns nil if `re` and `s` do not match. (def text-with-blank-lines ["En un lugar de la Mancha," "" " " "de cuyo nombre no quiero acordarme" " "]) ;; Let's count how many non-blank lines are there: (count (filter #(re-find #"\S" %) text-with-blank-lines)) 2 ;; Example inspired in 'Programming Clojure 3rd Ed.' 'Seq-in Stream'.

Note by paomian

the regex can't be a var?

(let [regex "abc"] (re-find #a "abc"))

this will get an error!

Note by blx

@paomian: The regex can be a variable, but the variable needs to be a regex.

This works fine:

(let [regex #"abc"] (re-find regex "abc"))

because the # reader macro for declaring regexes applies to the string right after it -- without doing any kind of substitution.

You could also do

(let [regex "abc"] (re-find (re-pattern regex) "abc"))

See also

• clojure.core/re-groups (0)
• clojure.core/re-matcher (0)
• clojure.core/re-pattern
• clojure.core/re-seq (4)
• clojure.core/re-matches (3)
• clojure.core/subs (3)
• clojure.string/replace (8)

---

Content from the matching ClojureDocs page, with authors credited on each contribution.