The long lost Emacs string manipulation library.

It's available on Melpa:

M-x package-install s

Or you can just dump s.el in your load path somewhere.

• s-trim (s)
• s-trim-left (s)
• s-trim-right (s)
• s-chomp (s)
• s-collapse-whitespace (s)
• s-word-wrap (len s)
• s-center (len s)
• s-pad-left (len padding s)
• s-pad-right (len padding s)

• s-truncate (len s)
• s-left (len s)
• s-right (len s)
• s-chop-left (len s)
• s-chop-right (len s)
• s-chop-suffix (suffix s)
• s-chop-suffixes (suffixes s)
• s-chop-prefix (prefix s)
• s-chop-prefixes (prefixes s)
• s-shared-start (s1 s2)
• s-shared-end (s1 s2)

• s-repeat (num s)
• s-concat (&rest strings)
• s-prepend (prefix s)
• s-append (suffix s)
• s-splice (needle n s)

• s-lines (s)
• s-match (regexp s &optional start)
• s-match-strings-all (regex string)
• s-matched-positions-all (regexp string &optional subexp-depth)
• s-slice-at (regexp s)
• s-split (separator s &optional omit-nulls)
• s-split-up-to (separator s n &optional omit-nulls)
• s-join (separator strings)

• s-equals? (s1 s2)
• s-less? (s1 s2)
• s-matches? (regexp s &optional start)
• s-blank? (s)
• s-present? (s)
• s-ends-with? (suffix s &optional ignore-case)
• s-starts-with? (prefix s &optional ignore-case)
• s-contains? (needle s &optional ignore-case)
• s-lowercase? (s)
• s-uppercase? (s)
• s-mixedcase? (s)
• s-capitalized? (s)
• s-numeric? (s)

• s-replace (old new s)
• s-replace-all (replacements s)
• s-downcase (s)
• s-upcase (s)
• s-capitalize (s)
• s-titleize (s)
• s-with (s form &rest more)
• s-index-of (needle s &optional ignore-case)
• s-reverse (s)
• s-presence (s)
• s-format (template replacer &optional extra)
• s-lex-format (format-str)
• s-count-matches (regexp s &optional start end)
• s-wrap (s prefix &optional suffix)

• s-split-words (s)
• s-lower-camel-case (s)
• s-upper-camel-case (s)
• s-snake-case (s)
• s-dashed-words (s)
• s-capitalized-words (s)
• s-titleized-words (s)
• s-word-initials (s)
• s-blank-str? (s)

Remove whitespace at the beginning and end of s.

(s-trim "trim ") ;; => "trim"
(s-trim " this") ;; => "this"
(s-trim " only  trims beg and end  ") ;; => "only  trims beg and end"

Remove whitespace at the beginning of s.

(s-trim-left "trim ") ;; => "trim "
(s-trim-left " this") ;; => "this"

Remove whitespace at the end of s.

(s-trim-right "trim ") ;; => "trim"
(s-trim-right " this") ;; => " this"

Remove one trailing \n, \r or \r\n from s.

(s-chomp "no newlines\n") ;; => "no newlines"
(s-chomp "no newlines\r\n") ;; => "no newlines"
(s-chomp "some newlines\n\n") ;; => "some newlines\n"

Convert all adjacent whitespace characters to a single space.

(s-collapse-whitespace "only   one space   please") ;; => "only one space please"
(s-collapse-whitespace "collapse \n all \t sorts of \r whitespace") ;; => "collapse all sorts of whitespace"

If s is longer than len, wrap the words with newlines.

(s-word-wrap 10 "This is too long") ;; => "This is\ntoo long"
(s-word-wrap 10 "This is way way too long") ;; => "This is\nway way\ntoo long"
(s-word-wrap 10 "It-wraps-words-but-does-not-break-them") ;; => "It-wraps-words-but-does-not-break-them"

If s is shorter than len, pad it with spaces so it is centered.

(s-center 5 "a") ;; => "  a  "
(s-center 5 "ab") ;; => "  ab "
(s-center 1 "abc") ;; => "abc"

If s is shorter than len, pad it with padding on the left.

(s-pad-left 3 "0" "3") ;; => "003"
(s-pad-left 3 "0" "23") ;; => "023"
(s-pad-left 3 "0" "1234") ;; => "1234"

If s is shorter than len, pad it with padding on the right.

(s-pad-right 3 "." "3") ;; => "3.."
(s-pad-right 3 "." "23") ;; => "23."
(s-pad-right 3 "." "1234") ;; => "1234"

If s is longer than len, cut it down to len - 3 and add ... at the end.

(s-truncate 6 "This is too long") ;; => "Thi..."
(s-truncate 16 "This is also too long") ;; => "This is also ..."
(s-truncate 16 "But this is not!") ;; => "But this is not!"

Returns up to the len first chars of s.

(s-left 3 "lib/file.js") ;; => "lib"
(s-left 3 "li") ;; => "li"

Returns up to the len last chars of s.

(s-right 3 "lib/file.js") ;; => ".js"
(s-right 3 "li") ;; => "li"

Remove the first len chars from s.

(s-chop-left 3 "lib/file.js") ;; => "/file.js"
(s-chop-left 3 "li") ;; => ""

Remove the last len chars from s.

(s-chop-right 3 "lib/file.js") ;; => "lib/file"
(s-chop-right 3 "li") ;; => ""

Remove suffix if it is at end of s.

(s-chop-suffix "-test.js" "penguin-test.js") ;; => "penguin"
(s-chop-suffix "\n" "no newlines\n") ;; => "no newlines"
(s-chop-suffix "\n" "some newlines\n\n") ;; => "some newlines\n"

Remove suffixes one by one in order, if they are at the end of s.

(s-chop-suffixes '("_test.js" "-test.js" "Test.js") "penguin-test.js") ;; => "penguin"
(s-chop-suffixes '("\r" "\n") "penguin\r\n") ;; => "penguin\r"
(s-chop-suffixes '("\n" "\r") "penguin\r\n") ;; => "penguin"

Remove prefix if it is at the start of s.

(s-chop-prefix "/tmp" "/tmp/file.js") ;; => "/file.js"
(s-chop-prefix "/tmp" "/tmp/tmp/file.js") ;; => "/tmp/file.js"

Remove prefixes one by one in order, if they are at the start of s.

(s-chop-prefixes '("/tmp" "/my") "/tmp/my/file.js") ;; => "/file.js"
(s-chop-prefixes '("/my" "/tmp") "/tmp/my/file.js") ;; => "/my/file.js"

Returns the longest prefix s1 and s2 have in common.

(s-shared-start "bar" "baz") ;; => "ba"
(s-shared-start "foobar" "foo") ;; => "foo"
(s-shared-start "bar" "foo") ;; => ""

Returns the longest suffix s1 and s2 have in common.

(s-shared-end "bar" "var") ;; => "ar"
(s-shared-end "foo" "foo") ;; => "foo"
(s-shared-end "bar" "foo") ;; => ""

Make a string of s repeated num times.

(s-repeat 10 " ") ;; => "          "
(s-concat (s-repeat 8 "Na") " Batman!") ;; => "NaNaNaNaNaNaNaNa Batman!"

Join all the string arguments into one string.

(s-concat "abc" "def" "ghi") ;; => "abcdefghi"

Concatenate prefix and s.

(s-prepend "abc" "def") ;; => "abcdef"

Concatenate s and suffix.

(s-append "abc" "def") ;; => "defabc"

Splice needle into s at position n. 0 is the beginning of the string, -1 is the end.

(s-splice "abc" 0 "def") ;; => "abcdef"
(s-splice "abc" -1 "def") ;; => "defabc"
(s-splice "needle" 2 "A  in a haystack.") ;; => "A needle in a haystack."

Splits s into a list of strings on newline characters.

(s-lines "abc\ndef\nghi") ;; => '("abc" "def" "ghi")
(s-lines "abc\rdef\rghi") ;; => '("abc" "def" "ghi")
(s-lines "abc\r\ndef\r\nghi") ;; => '("abc" "def" "ghi")

When the given expression matches the string, this function returns a list of the whole matching string and a string for each matched subexpressions. If it did not match the returned value is an empty list (nil).

When start is non-nil the search will start at that index.

(s-match "^def" "abcdefg") ;; => nil
(s-match "^abc" "abcdefg") ;; => '("abc")
(s-match "^/.*/\\([a-z]+\\)\\.\\([a-z]+\\)" "/some/weird/file.html") ;; => '("/some/weird/file.html" "file" "html")

Return a list of matches for regex in string.

Each element itself is a list of matches, as per match-string. Multiple matches at the same position will be ignored after the first.

(s-match-strings-all "{\\([^}]+\\)}" "x is {x} and y is {y}") ;; => '(("{x}" "x") ("{y}" "y"))
(s-match-strings-all "ab." "abXabY") ;; => '(("abX") ("abY"))
(s-match-strings-all "\\<" "foo bar baz") ;; => '(("") ("") (""))

Return a list of matched positions for regexp in string. subexp-depth is 0 by default.

(s-matched-positions-all "l+" "{{Hello}} World, {{Emacs}}!" 0) ;; => '((4 . 6) (13 . 14))
(s-matched-positions-all "{{\\(.+?\\)}}" "{{Hello}} World, {{Emacs}}!" 0) ;; => '((0 . 9) (17 . 26))
(s-matched-positions-all "{{\\(.+?\\)}}" "{{Hello}} World, {{Emacs}}!" 1) ;; => '((2 . 7) (19 . 24))

Slices s up at every index matching regexp.

(s-slice-at "-" "abc") ;; => '("abc")
(s-slice-at "-" "abc-def") ;; => '("abc" "-def")
(s-slice-at "[.#]" "abc.def.ghi#id") ;; => '("abc" ".def" ".ghi" "#id")

Split s into substrings bounded by matches for regexp separator. If omit-nulls is non-nil, zero-length substrings are omitted.

This is a simple wrapper around the built-in split-string.

(s-split "|" "a|bc|12|3") ;; => '("a" "bc" "12" "3")
(s-split ":" "a,c,d") ;; => '("a,c,d")
(s-split "\n" "z\nefg\n") ;; => '("z" "efg" "")

Split s up to n times into substrings bounded by matches for regexp separator.

If omit-nulls is non-nil, zero-length substrings are omitted.

See also s-split.

(s-split-up-to "\\s-*-\\s-*" "Author - Track-number-one" 1) ;; => '("Author" "Track-number-one")
(s-split-up-to "\\s-*-\\s-*" "Author - Track-number-one" 2) ;; => '("Author" "Track" "number-one")
(s-split-up-to "|" "foo||bar|baz|qux" 3 t) ;; => '("foo" "bar" "baz|qux")

Join all the strings in strings with separator in between.

(s-join "+" '("abc" "def" "ghi")) ;; => "abc+def+ghi"
(s-join "\n" '("abc" "def" "ghi")) ;; => "abc\ndef\nghi"

Is s1 equal to s2?

This is a simple wrapper around the built-in string-equal.

(s-equals? "abc" "ABC") ;; => nil
(s-equals? "abc" "abc") ;; => t

Is s1 less than s2?

This is a simple wrapper around the built-in string-lessp.

(s-less? "abc" "abd") ;; => t
(s-less? "abd" "abc") ;; => nil
(s-less? "abc" "abc") ;; => nil

Does regexp match s? If start is non-nil the search starts at that index.

This is a simple wrapper around the built-in string-match-p.

(s-matches? "^[0-9]+$" "123") ;; => t
(s-matches? "^[0-9]+$" "a123") ;; => nil
(s-matches? "1" "1a" 1) ;; => nil

Is s nil or the empty string?

(s-blank? "") ;; => t
(s-blank? nil) ;; => t
(s-blank? " ") ;; => nil

Is s anything but nil or the empty string?

(s-present? "") ;; => nil
(s-present? nil) ;; => nil
(s-present? " ") ;; => t

Does s end with suffix?

If ignore-case is non-nil, the comparison is done without paying attention to case differences.

Alias: s-suffix?

(s-ends-with? ".md" "readme.md") ;; => t
(s-ends-with? ".MD" "readme.md") ;; => nil
(s-ends-with? ".MD" "readme.md" t) ;; => t

Does s start with prefix?

If ignore-case is non-nil, the comparison is done without paying attention to case differences.

Alias: s-prefix?. This is a simple wrapper around the built-in string-prefix-p.

(s-starts-with? "lib/" "lib/file.js") ;; => t
(s-starts-with? "LIB/" "lib/file.js") ;; => nil
(s-starts-with? "LIB/" "lib/file.js" t) ;; => t

Does s contain needle?

If ignore-case is non-nil, the comparison is done without paying attention to case differences.

(s-contains? "file" "lib/file.js") ;; => t
(s-contains? "nope" "lib/file.js") ;; => nil
(s-contains? "^a" "it's not ^a regexp") ;; => t

Are all the letters in s in lower case?

(s-lowercase? "file") ;; => t
(s-lowercase? "File") ;; => nil
(s-lowercase? "filä") ;; => t

Are all the letters in s in upper case?

(s-uppercase? "HULK SMASH") ;; => t
(s-uppercase? "Bruce no smash") ;; => nil
(s-uppercase? "FöB") ;; => nil

Are there both lower case and upper case letters in s?

(s-mixedcase? "HULK SMASH") ;; => nil
(s-mixedcase? "Bruce no smash") ;; => t
(s-mixedcase? "BRÜCE") ;; => nil

In s, is the first letter upper case, and all other letters lower case?

(s-capitalized? "Capitalized") ;; => t
(s-capitalized? "I am capitalized") ;; => t
(s-capitalized? "I Am Titleized") ;; => nil

Is s a number?

(s-numeric? "123") ;; => t
(s-numeric? "onetwothree") ;; => nil
(s-numeric? "7a") ;; => nil

Replaces old with new in s.

(s-replace "file" "nope" "lib/file.js") ;; => "lib/nope.js"
(s-replace "^a" "\\1" "it's not ^a regexp") ;; => "it's not \\1 regexp"

replacements is a list of cons-cells. Each car is replaced with cdr in s.

(s-replace-all '(("lib" . "test") ("file" . "file_test")) "lib/file.js") ;; => "test/file_test.js"
(s-replace-all '(("lib" . "test") ("test" . "lib")) "lib/test.js") ;; => "test/lib.js"

Convert s to lower case.

This is a simple wrapper around the built-in downcase.

(s-downcase "ABC") ;; => "abc"

Convert s to upper case.

This is a simple wrapper around the built-in upcase.

(s-upcase "abc") ;; => "ABC"

Convert the first word's first character to upper case and the rest to lower case in s.

(s-capitalize "abc DEF") ;; => "Abc def"
(s-capitalize "abc.DEF") ;; => "Abc.def"

Convert each word's first character to upper case and the rest to lower case in s.

This is a simple wrapper around the built-in capitalize.

(s-titleize "abc DEF") ;; => "Abc Def"
(s-titleize "abc.DEF") ;; => "Abc.Def"

Threads s through the forms. Inserts s as the last item in the first form, making a list of it if it is not a list already. If there are more forms, inserts the first form as the last item in second form, etc.

(s-with "   hulk smash   " s-trim s-upcase) ;; => "HULK SMASH"
(s-with "My car is a Toyota" (s-replace "car" "name") (s-replace "a Toyota" "Bond") (s-append ", James Bond")) ;; => "My name is Bond, James Bond"
(s-with "abc \ndef  \nghi" s-lines (mapcar 's-trim) (s-join "-") s-reverse) ;; => "ihg-fed-cba"

Returns first index of needle in s, or nil.

If ignore-case is non-nil, the comparison is done without paying attention to case differences.

(s-index-of "abc" "abcdef") ;; => 0
(s-index-of "CDE" "abcdef" t) ;; => 2
(s-index-of "n.t" "not a regexp") ;; => nil

Return the reverse of s.

(s-reverse "abc") ;; => "cba"
(s-reverse "ab xyz") ;; => "zyx ba"
(s-reverse "") ;; => ""

Return s if it's s-present?, otherwise return nil.

(s-presence nil) ;; => nil
(s-presence "") ;; => nil
(s-presence "foo") ;; => "foo"

Format template with the function replacer.

replacer takes an argument of the format variable and optionally an extra argument which is the extra value from the call to s-format.

Several standard s-format helper functions are recognized and adapted for this:

(s-format "${name}" 'gethash hash-table)
(s-format "${name}" 'aget alist)
(s-format "$0" 'elt sequence)

The replacer function may be used to do any other kind of transformation.

(s-format "help ${name}! I'm ${malady}" 'aget '(("name" . "nic") ("malady" . "on fire"))) ;; => "help nic! I'm on fire"
(s-format "hello ${name}, nice day" (lambda (var-name) "nic")) ;; => "hello nic, nice day"
(s-format "hello $0, nice $1" 'elt '("nic" "day")) ;; => "hello nic, nice day"

s-format with the current environment.

format-str may use the s-format variable reference to refer to any variable:

(let ((x 1)) (s-lex-format "x is: ${x}"))

The values of the variables are interpolated with "%s" unless the variable s-lex-value-as-lisp is t and then they are interpolated with "%S".

(let ((x 1)) (s-lex-format "x is ${x}")) ;; => "x is 1"
(let ((str1 "this") (str2 "that")) (s-lex-format "${str1} and ${str2}")) ;; => "this and that"
(let ((foo "Hello\\nWorld")) (s-lex-format "${foo}")) ;; => "Hello\\nWorld"

Count occurrences of regexp in `s'.

start, inclusive, and end, exclusive, delimit the part of s to match.

(s-count-matches "a" "aba") ;; => 2
(s-count-matches "a" "aba" 0 2) ;; => 1
(s-count-matches "\\w\\{2\\}[0-9]+" "ab1bab2frobinator") ;; => 2

Wrap string s with prefix and optionally suffix.

Return string s with prefix prepended. If suffix is present, it is appended, otherwise prefix is used as both prefix and suffix.

(s-wrap "foo" "\"") ;; => "\"foo\""
(s-wrap "foo" "(" ")") ;; => "(foo)"
(s-wrap "foo" "bar") ;; => "barfoobar"

Split s into list of words.

(s-split-words "under_score") ;; => '("under" "score")
(s-split-words "some-dashed-words") ;; => '("some" "dashed" "words")
(s-split-words "evenCamelCase") ;; => '("even" "Camel" "Case")

Convert s to lowerCamelCase.

(s-lower-camel-case "some words") ;; => "someWords"
(s-lower-camel-case "dashed-words") ;; => "dashedWords"
(s-lower-camel-case "under_scored_words") ;; => "underScoredWords"

Convert s to UpperCamelCase.

(s-upper-camel-case "some words") ;; => "SomeWords"
(s-upper-camel-case "dashed-words") ;; => "DashedWords"
(s-upper-camel-case "under_scored_words") ;; => "UnderScoredWords"

Convert s to snake_case.

(s-snake-case "some words") ;; => "some_words"
(s-snake-case "dashed-words") ;; => "dashed_words"
(s-snake-case "camelCasedWords") ;; => "camel_cased_words"

Convert s to dashed-words.

(s-dashed-words "some words") ;; => "some-words"
(s-dashed-words "under_scored_words") ;; => "under-scored-words"
(s-dashed-words "camelCasedWords") ;; => "camel-cased-words"

Convert s to Capitalized words.

(s-capitalized-words "some words") ;; => "Some words"
(s-capitalized-words "under_scored_words") ;; => "Under scored words"
(s-capitalized-words "camelCasedWords") ;; => "Camel cased words"

Convert s to Titleized Words.

(s-titleized-words "some words") ;; => "Some Words"
(s-titleized-words "under_scored_words") ;; => "Under Scored Words"
(s-titleized-words "camelCasedWords") ;; => "Camel Cased Words"

Convert s to its initials.

(s-word-initials "some words") ;; => "sw"
(s-word-initials "under_scored_words") ;; => "usw"
(s-word-initials "camelCasedWords") ;; => "cCW"

Is s nil or the empty string or string only contains whitespace?

(s-blank-str? "  \t \r   ") ;; => t
(s-blank-str? "    ") ;; => t
(s-blank-str? "\t\r") ;; => t

Imagine looking through the function list and seeing s-ends-with?, but s-starts-with? is nowhere to be found. Why? Well, because Emacs already has string-prefix-p. Now you're starting out slightly confused, then have to go somewhere else to dig for the command you were looking for.

The wrapping functions serve as both documentation for existing functions and makes for a consistent API.

• inflections package provides functions for strings pluralization and singularization.

• levenshtein package provides a function to calculate the Levenshtein distance between two strings.

• string-utils is another general string manipulation library.

• Alias all functions ending in ? (Tianxiang Xiong)
• Add s-blank-str? (Aborn Jiang)
• Several bugfixes

• Add s-matched-positions-all (ono hiroko)

• Add s-wrap (Johan Andersson)
• Add s-split-up-to (Matus Goljer)
• Fix s-reverse for Unicode combining characters. (Christopher Wellons)

• Add s-count-matches (Lars Andersen)

• Add s-present? and s-present? (Johan Andersson)
• Better handling of international characters

• Add s-word-initials (Sylvain Rousseau)
• Better handling of camel cased strings (@Bruce-Connor)

• Add s-pad-left and s-pad-right
• Bugfixes for s-format (Nic Ferrier)

• Add s-all-match-strings (Geoff Gole)
• Add s-lex-format (Nic Ferrier)

• Add s-capitalized?
• Add s-replace-all
• Add s-slice-at
• Add s-split alias for split-string (Rüdiger Sonderfeld)
• Add s-less? predicate (Rüdiger Sonderfeld)
• Add START parameter to s-matches? (Rüdiger Sonderfeld)
• Bugfixes

• Add s-numeric?
• Add s-match (Arthur Andersen)
• Add s-format (Nic Ferrier)
• Move .el files out of root to avoid problems with require.

• Breaking change: s-capitalize now converts the first word's first character to upper case and the rest to lower case. s-titleize works like the old s-capitalize and capitalizes each word. (Johan Andersson)

• s-capitalized-words and s-titleized-words mirror this change.

• Arthur Andersen contributed s-match
• Rolando contributed s-shared-start and s-shared-end
• Johan Andersson contributed s-presence, s-present? and fixed s-titleize vs s-capitalize
• Nic Ferrier added s-format and s-lex-format
• Rüdiger Sonderfeld contributed s-less?, s-split and several bugfixes.
• Geoff Gole contributed s-all-match-strings
• Sylvain Rousseau contributed s-word-initials
• Lars Andersen contributed s-count-matches
• ono hiroko contributed s-matched-positions-all

Thanks!

Yes, please do. Pure functions in the string manipulation realm only, please. There's a suite of tests in dev/examples.el, so remember to add tests for your function, or I might break it later.

You'll find the repo at:

https://github.com/magnars/s.el

Run the tests with

./run-tests.sh

Create the docs with

./create-docs.sh

I highly recommend that you install these as a pre-commit hook, so that the tests are always running and the docs are always in sync:

cp pre-commit.sh .git/hooks/pre-commit

Oh, and don't edit README.md directly, it is auto-generated. Change readme-template.md or examples-to-docs.el instead.

Copyright (C) 2012-2022 Magnar Sveen

Authors: Magnar Sveen [email protected] Maintainer: Jason Milkins [email protected] Keywords: strings

This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.