cuerdas.core — funcool/cuerdas 2.0.5

<< clj/s macro deprecated

(<< & strings)

A backward compatibility alias for istr macro.

<<- clj/s

(<<- s)

(<<- r s)

Unindent multiline text. Uses either a supplied regex or the shortest beginning-of-line to non-whitespace distance

alnum? clj/s

(alnum? s)

Checks if a string contains only alphanumeric characters.

alpha-numeric? clj/s deprecated

alpha? clj/s

(alpha? s)

Checks if a string contains only alpha characters.

blank? clj/s

(blank? s)

Checks if a string is empty or contains only whitespace.

camel clj/s

(camel s)

Output will be: lowerUpperUpperNoSpaces accepts strings and keywords

capital clj/s

(capital s)

Uppercases the first character of a string or keyword

capitalize clj/s deprecated

caseless= clj/s

(caseless= s1 s2)

Compare strings in a case-insensitive manner.

This function is locale independent.

chars clj/s

(chars s)

Split a string in a seq of chars.

classify clj/s deprecated

clean clj/s

(clean s)

Trim and replace multiple spaces with a single space.

collapse-whitespace clj/s

(collapse-whitespace s)

Converts all adjacent whitespace characters to a single space.

contains? clj/s deprecated

css-selector clj/s

(css-selector s)

Output will be either: (js-selector "LeadingDash") ;; => -leading-dash (js-selector "noLeadingDash") ;; => no-leading-dash

accepts keywords and strings, with any standard delimiter

dasherize clj/s deprecated

digits? clj/s

(digits? s)

Checks if a string contains only digit characters.

empty-or-nil? clj/s

(empty-or-nil? s)

Convenient helper for check emptines or if value is nil.

empty? clj/s

(empty? s)

Checks if a string is empty.

ends-with? clj/s

(ends-with? s suffix)

Check if the string ends with suffix.

endswith? clj/s deprecated

escape-html clj/s

(escape-html s)

fmt clj/s

A shorter alias to format function.

format clj/s

(format s & more)

Simple string interpolation.

human clj/s

(human s)

Output will be: lower cased and space separated accepts strings and keywords

humanize clj/s deprecated

includes? clj/s

(includes? s subs)

Determines whether a string contains a substring.

istr clj/s macro

(istr & strings)

Accepts one or more strings; emits a str invocation that concatenates the string data and evaluated expressions contained within that argument. Evaluation is controlled using ~{} and ~() forms. The former is used for simple value replacement using clojure.core/str; the latter can be used to embed the results of arbitrary function invocation into the produced string.

Examples:

user=> (def v 30.5)
#'user/v
user=> (istr "This trial required ~{v}ml of solution.")
"This trial required 30.5ml of solution."
user=> (istr "There are ~(int v) days in November.")
"There are 30 days in November."
user=> (def m {:a [1 2 3]})
#'user/m
user=> (istr "The total for your order is $~(->> m :a (apply +)).")
"The total for your order is $6."
user=> (<< "Just split a long interpolated string up into ~(-> m :a (get 0)), "
         "~(-> m :a (get 1)), or even ~(-> m :a (get 2)) separate strings "
         "if you don't want a << expression to end up being e.g. ~(* 4 (int v)) "
         "columns wide.")
"Just split a long interpolated string up into 1, 2, or even 3 separate strings if you don't want a << expression to end up being e.g. 120 columns wide."

Note that quotes surrounding string literals within ~() forms must be escaped.

join clj/s

(join coll)

(join separator coll)

Joins strings together with given separator.

js-selector clj/s

(js-selector s)

Output will be either: (js-selector "-pascal-case-me") ;; => PascalCaseMe (js-selector "camel-case-me") ;; => camelCaseMe

accepts keywords and strings, with any standard delimiter

kebab clj/s

(kebab s)

Output will be: lower-cased-and-separated-with-dashes accepts strings and keywords

keyword clj/s

(keyword k)

(keyword n k)

Safer version of clojure keyword, accepting a symbol for the namespace and kebab-casing the key

letters? clj/s

(letters? s)

Checks if string contains only letters. This function will use all the unicode range.

lines clj/s

(lines s)

Return a list of the lines in the string.

locale-caseless= clj/s≠

clj

(locale-caseless= s1 s2)

(locale-caseless= s1 s2 locale)

cljs

(locale-caseless= s1 s2)

Compare strings in a case-insensitive manner respecting the current locale.

An optional locale can be passed as third argument (only on JVM).

locale-lower clj/s≠

clj

(locale-lower s)

(locale-lower s locale)

cljs

(locale-lower s)

Converts string to all lower-case respecting the current system locale.

In the jvm you can provide a concrete locale to use as the second optional argument.

locale-upper clj/s≠

clj

(locale-upper s)

(locale-upper s locale)

cljs

(locale-upper s)

Converts string to all upper-case respecting the current system locale.

In the jvm you can provide a concrete locale to use as the second optional argument.

lower clj/s

(lower s)

Converts string to all lower-case.

This function works in strictly locale independent way, if you want a localized version, just use locale-lower

lstrip clj/s

ltrim clj/s

(ltrim s)

(ltrim s chs)

Removes whitespace or specified characters from left side of string.

numeric? clj/s

(numeric? s)

Check if a string contains only numeric values.

one-of? clj/s

(one-of? coll s)

Returns true if s can be found in coll.

pad clj/s

(pad s & [{:keys [length padding type] :or {length 0 padding " " type :left}}])

Pads the str with characters until the total string length is equal to the passed length parameter. By default, pads on the left with the space char.

parse-double clj/s

(parse-double s)

Return the double value from string.

parse-float clj/s deprecated

parse-int clj/s

(parse-int s)

Return the number value in integer form.

parse-long clj/s deprecated

parse-number clj/s

(parse-number s)

General purpose function for parse number like string to number. It works with both integers and floats.

pascal clj/s

(pascal s)

Output will be: CapitalizedAndTouchingTheNext accepts strings and keywords

phrase clj/s

(phrase s)

Output will be: Space separated with the first letter capitalized. accepts strings and keywords

prune clj/s

(prune s num)

(prune s num subs)

Truncates a string to a certain length and adds '...' if necessary.

quote clj/s

(quote s)

(quote s qchar)

Quotes a string.

repeat clj/s

(repeat s)

(repeat s n)

Repeats string n times.

replace clj/s

(replace s match replacement)

Replaces all instance of match with replacement in s.

The replacement is literal (i.e. none of its characters are treated specially) for all cases above except pattern / string.

In match is pattern instance, replacement can contain $1, $2, etc. will be substituted with string that matcher the corresponding parenthesized group in pattern.

If you wish your replacement string to be used literary, use (cuerdas.regexp/escape replacement).

Example: (replace "Almost Pig Latin" #"\b(\w)(\w+)\b" "$2$1ay") ;; => "lmostAay igPay atinLay"

replace-first clj/s

(replace-first s match replacement)

Replaces first instance of match with replacement in s.

reverse clj/s

(reverse s)

Return string reversed.

rstrip clj/s

rtrim clj/s

(rtrim s)

(rtrim s chs)

Removes whitespace or specified characters from right side of string.

slice clj/s

(slice s begin)

(slice s begin end)

Extracts a section of a string and returns a new string.

slug clj/s

(slug s)

Transform text into a URL slug.

slugify clj/s deprecated

snake clj/s

(snake s)

Output will be: lower_cased_and_underscore_separated accepts strings and keywords

split clj/s

(split s)

(split s sep)

(split s sep num)

Splits a string on a separator a limited number of times. The separator can be a string, character or Pattern (clj) / RegExp (cljs) instance.

starts-with? clj/s

(starts-with? s prefix)

Check if the string starts with prefix.

startswith? clj/s deprecated

strip clj/s

strip-newlines clj/s

(strip-newlines s)

Takes a string and replaces newlines with a space. Multiple lines are replaced with a single space.

strip-prefix clj/s

(strip-prefix s prefix)

Strip prefix in more efficient way.

strip-suffix clj/s

(strip-suffix s suffix)

Strip suffix in more efficient way.

strip-tags clj/s

(strip-tags s)

(strip-tags s tags)

(strip-tags s tags mapping)

Remove html tags from string.

stylize clj/s

(stylize s every-fn join-with)

(stylize s first-fn rest-fn join-with)

substr-between clj/s

(substr-between s prefix suffix)

Find string that is nested in between two strings. Return first match

surround clj/s

(surround s wrap)

Surround a string with another string or character.

title clj/s

(title s)

Output will be: Each Word Capitalized And Separated With Spaces accepts strings and keywords

titleize clj/s deprecated

to-bool clj/s

(to-bool s)

Returns true for 1/on/true/yes string values (case-insensitive), false otherwise.

trim clj/s

(trim s)

(trim s chs)

Removes whitespace or specified characters from both ends of string.

underscore clj/s deprecated

underscored clj/s deprecated

unescape-html clj/s

(unescape-html s)

Converts entity characters to HTML equivalents.

unlines clj/s

(unlines s)

Returns a new string joining a list of strings with a newline char (\n).

unquote clj/s

(unquote s)

(unquote s qchar)

Unquote a string.

unsurround clj/s

(unsurround s surrounding)

Unsurround a string surrounded by another string or character.

upper clj/s

(upper s)

Converts string to all upper-case.

This function works in strictly locale independent way, if you want a localized version, just use locale-upper

uslug clj/s

(uslug s)

Unicode friendly version of slug function.

word? clj/s

(word? s)

Checks if a string contains only the word characters. This function will use all the unicode range.

words clj/s

(words s)

(words s re)

Returns a vector of the words in the string.