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") ;; => tIs 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") ;; => nilDoes 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) ;; => nilIs s nil or the empty string?
(s-blank? "") ;; => t
(s-blank? nil) ;; => t
(s-blank? " ") ;; => nilIs s anything but nil or the empty string?
(s-present? "") ;; => nil
(s-present? nil) ;; => nil
(s-present? " ") ;; => tDoes 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) ;; => tDoes 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) ;; => tDoes 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") ;; => tAre all the letters in s in lower case?
(s-lowercase? "file") ;; => t
(s-lowercase? "File") ;; => nil
(s-lowercase? "filä") ;; => tAre all the letters in s in upper case?
(s-uppercase? "HULK SMASH") ;; => t
(s-uppercase? "Bruce no smash") ;; => nil
(s-uppercase? "FöB") ;; => nilAre 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") ;; => nilIn 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") ;; => nilIs s a number?
(s-numeric? "123") ;; => t
(s-numeric? "onetwothree") ;; => nil
(s-numeric? "7a") ;; => nilReplaces 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") ;; => nilReturn 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") ;; => 2Wrap 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") ;; => tImagine 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-reversefor Unicode combining characters. (Christopher Wellons)
- Add
s-count-matches(Lars Andersen)
- Add
s-present?ands-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-leftands-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-splitalias forsplit-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-capitalizenow converts the first word's first character to upper case and the rest to lower case.s-titleizeworks like the olds-capitalizeand capitalizes each word. (Johan Andersson) -
s-capitalized-wordsands-titleized-wordsmirror this change.
- Arthur Andersen contributed
s-match - Rolando contributed
s-shared-startands-shared-end - Johan Andersson contributed
s-presence,s-present?and fixeds-titleizevss-capitalize - Nic Ferrier added
s-formatands-lex-format - Rüdiger Sonderfeld contributed
s-less?,s-splitand 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/.
React
Typescript
Django
Laravel
Facebook
Microsoft
Google
Alibaba
D3
Tencent