hara.string.base.common — hara/base 3.0.11

*sep* clj

blank? clj

(blank? s)

checks if string is empty or nil

(blank? nil) => true

(blank? "") => true

capital-case clj

(capital-case s)

converts a string object to capital case

(capital-case "hello.World") => "Hello.world"

(string/capital-case 'hello.World) => 'Hello.world

caseless= clj

(caseless= x y)

compares two values ignoring case

(caseless= "heLLo" "HellO") => true

(string/caseless= 'heLLo :HellO) => true

ends-with? clj

(ends-with? s substr)

checks if string ends with another

(ends-with? "hello" "lo") => true

(string/ends-with? 'hello 'lo) => true

includes? clj

(includes? s substr)

checks if first string contains the second

(includes? "hello" "ell") => true

(string/includes? 'hello 'ell) => true

join clj

(join coll)

(join seperator coll)

like join but used with ->> opts

(join "." ["a" "b" "c"]) => "a.b.c"

(string/join "." '[a b c]) => 'a.b.c

joinl clj

(joinl coll)

(joinl coll separator)

joins an array using a separator

(joinl ["a" "b" "c"] ".") => "a.b.c"

(joinl ["a" "b" "c"]) => "abc"

(string/joinl [:a :b :c] "-") => :a-b-c

lower-case clj

(lower-case s)

converts a string object to lower case

(lower-case "Hello.World") => "hello.world"

(string/lower-case 'Hello.World) => 'hello.world

replace clj

(replace s match replacement)

replace value in string with another

(replace "hello" "el" "AL") => "hALlo"

(string/replace :hello "el" "AL") => :hALlo

reverse clj

(reverse s)

reverses the string

(reverse "hello") => "olleh"

(string/reverse :hello) => :olleh

split clj

(split s re)

splits the string into tokens

(split "a b c" #" ") => ["a" "b" "c"]

(string/split :a.b.c (re-pattern ".")) => [:a :b :c]

split-lines clj

(split-lines s)

splits the string into separate lines

(split-lines "a\nb\nc") => ["a" "b" "c"]

starts-with? clj

(starts-with? s substr)

checks if string starts with another

(starts-with? "hello" "hel") => true

(string/starts-with? 'hello 'hel) => true

trim clj

(trim s)

trims the string of whitespace

(trim " hello ") => "hello"

trim-left clj

(trim-left s)

trims the string of whitespace on left

(trim-left " hello ") => "hello "

trim-newlines clj

(trim-newlines s)

removes newlines from right

(trim-newlines "\n\n hello \n\n") => "\n\n hello "

trim-right clj

(trim-right s)

trims the string of whitespace on right

(trim-right " hello ") => "hello"

upper-case clj

(upper-case s)

converts a string object to upper case

(upper-case "hello-world") => "HELLO-WORLD"

(string/upper-case :hello-world) => :HELLO-WORLD