Share your code. npm Orgs help your team discover, share, and reuse code. Create a free org »

    underscore.string.fppublic

    Underscore.string.fp Build Status

    This is a wrapper for underscore.string to use it as a FP-library or with a library like lodash-fp or Ramda

    Usage

    In Node.js and Browserify

    Install from npm

    npm install underscore.string.fp
    

    Require individual functions

    var include = require("underscore.string.fp/include");
     
    var includeHello = include('Hello');
     
    includeHello("Hello world!");
    // => true
     
    includeHello("Nope");
    // => false

    or load the full library to compose functions

    var rockit = S(
      S.titleize(),
      S.insert('rocks', 9),
      S.trim('_')
    );
     
    // S.titleize(S.insert('rocks', 9, S.trim('_', "__stoeffel !__")));
    rockit("__stoeffel !__");
    // => "Stoeffel Rocks!"

    but especially when using with Browserify the individual function approach is recommended because using it you only add those functions to your bundle you use.

    Others

    The dist/underscore.string.fp.js file is an UMD build. You can load it using an AMD loader such as RequireJS or just stick it to a web page and access the library from the S global.

    Ramda integration

    You can use it with ramda.

    R.map(S.camelize(), [
      'Moo boo',
      'Foo bar'
    ]);
    // => ['mooBoo', 'fooBoo']
    R.filter(S.startsWith('.'), [
      '.vimrc',
      'foo.md',
      '.zshrc'
    ]);
    // => ['.vimrc', '.zshrc']

    lodash-fp integration

    You can use it with lodash-fp.

    _.map(S.camelize(), [
      'Moo boo',
      'Foo bar'
    ]);
    // => ['mooBoo', 'fooBoo']
    _.filter(S.startsWith('.'), [
      '.vimrc',
      'foo.md',
      '.zshrc'
    ]);
    // => ['.vimrc', '.zshrc']

    Download

    API

    Individual functions

    numberFormat(number) => string

    Formats the numbers.

    numberFormat(1000);
    // => "1,000"

    numberFormatDecimal(decimals, number) => string

    Formats the numbers.

    numberFormatDecimal(2)(1000);
    // => "1,000.00"

    numberFormatSeparator(decimalSeparator, orderSeparator, decimal, number) => string

    Formats the numbers.

    numberFormatSeparator(".", "'", 5, 123456789.123);
    // => "123'456'789.12300"

    levenshtein(string1, string2) => number

    Calculates Levenshtein distance between two strings.

    levenshtein("kitten")("kittah");
    // => 2

    capitalize(string) => string

    Converts first letter of the string to uppercase.

    capitalize()("foo Bar");
    // => "Foo Bar"
     
    capitalize("foo Bar");
    // => "Foo Bar"

    decapitalize(string) => string

    Converts first letter of the string to lowercase.

    decapitalize()("Foo Bar");
    // => "foo Bar"
     
    decapitalize("Foo Bar");
    // => "foo Bar"

    chop(step, string) => array

    chop(3)("whitespace");
    // => ["whi", "tes", "pac", "e"]

    clean(string) => string

    Trim and replace multiple spaces with a single space.

    clean()(" foo    bar   ");
    // => "foo bar"
     
    clean(" foo    bar   ");
    // => "foo bar"

    chars(string) => array

    chars()("Hello");
    // => ["H", "e", "l", "l", "o"]
     
    chars("Hello");
    // => ["H", "e", "l", "l", "o"]

    swapCase(string) => string

    Returns a copy of the string in which all the case-based characters have had their case swapped.

    swapCase()("hELLO");
    // => "Hello"
     
    swapCase("hELLO");
    // => "Hello"

    include(substring, string) => boolean

    Tests if string contains a substring.

    include("ob")("foobar");
    // => true

    count(substring, string) => number

    count("l")("Hello world");
    // => 3

    escapeHTML(string) => string

    Converts HTML special characters to their entity equivalents.

    escapeHTML()("<div>Blah blah blah</div>");
    // => "&lt;div&gt;Blah blah blah&lt;/div&gt;"
     
    escapeHTML("<div>Blah blah blah</div>");
    // => "&lt;div&gt;Blah blah blah&lt;/div&gt;"

    unescapeHTML(string) => string

    Converts entity characters to HTML equivalents.

    unescapeHTML()("&lt;div&gt;Blah blah blah&lt;/div&gt;");
    // => "<div>Blah blah blah</div>"
     
    unescapeHTML("&lt;div&gt;Blah blah blah&lt;/div&gt;");
    // => "<div>Blah blah blah</div>"

    insert(substring, index, string) => string

    insert("world", 6)("Hello ");
    // => "Hello world"

    replaceAll(replace, find, string) => string

    replaceAll("a")("o")("foo");
    // => "faa"

    replaceAllIgnoreCase(replace, find, string) => string

    replaceAll("a")("o")("fOo");
    // => "faa"

    isBlank(string) => boolean

    isBlank(""); // => true
    isBlank("\n"); // => true
    isBlank(" "); // => true
    isBlank("a"); // => false

    join(separator, strings) => string

    Joins strings together with given separator

    join(" ")(["foo", "bar"]);
    // => "foo bar"

    lines(str) => array

    Split lines to an array

    lines()("Hello\nWorld");
    // => ["Hello", "World"]
     
    lines("Hello\nWorld");
    // => ["Hello", "World"]

    dedent(str) => string

    Dedent unnecessary indentation

    Credits go to @sindresorhus. This implementation is similar to https://github.com/sindresorhus/strip-indent

    dedent()("  Hello\n    World");
    // => "Hello\n  World"
     
    dedent("\t\tHello\n\t\t\t\tWorld");
    // => "Hello\n\t\tWorld"

    dedentPattern(pattern, str) => string

    Dedent by a pattern.

    dedentPattern("  ")("    Hello\n    World"); // Dedent by 2 spaces
    // => "  Hello\n  World"

    reverse(string) => string

    Return reversed string:

    reverse()("foobar");
    // => "raboof"
     
    reverse("foobar");
    // => "raboof"

    splice(substring, howmany, index, string) => string

    Like an array splice.

    splice("epeli")(7)(30)("https://edtsech@bitbucket.org/edtsech/underscore.strings");
    // => "https://edtsech@bitbucket.org/epeli/underscore.strings"

    startsWith(starts, string) => boolean

    This method checks whether the string begins with starts.

    startsWith("image")("image.gif");
    // => true

    startsWithAt(starts, position, string) => boolean

    This method checks whether the string begins with starts at position.

    startsWithAt(1)("vim")(".vimrc");
    // => true

    endsWith(ends, string) => boolean

    This method checks whether the string ends with ends.

    endsWith("gif")("image.gif");
    // => true

    endsWithAt(position, ends, string) => boolean

    This method checks whether the string ends with ends at position.

    endsWithAt(9)("old")("image.old.gif");
    // => true

    pred(string) => string

    Returns the predecessor to str.

    pred()("b");
    // => "a"
     
    pred("B");
    // => "A"

    succ(string) => string

    Returns the successor to str.

    succ()("a");
    // => "b"
     
    succ("A");
    // => "B"

    titleize(string) => string

    titleize()("my name is epeli");
    // => "My Name Is Epeli"
     
    titleize("my name is epeli");
    // => "My Name Is Epeli"

    camelize(string) => string

    Converts underscored or dasherized string to a camelized one.

    camelize("moz-transform");
    // => "mozTransform"
     
    camelize("-moz-transform");
    // => "mozTransform"
     
    camelize("_moz_transform");
    // => "mozTransform"
     
    camelize("Moz-transform");
    // => "mozTransform"

    pascalize(string) => string

    Converts underscored or dasherized string to a pascalized one. Begins with a lower case letter unless it starts with an underscore, dash or an upper case letter.

    pascalize("moz-transform");
    // => "mozTransform"
     
    pascalize("-moz-transform");
    // => "MozTransform"
     
    pascalize("_moz_transform");
    // => "MozTransform"
     
    pascalize("Moz-transform");
    // => "MozTransform"

    classify(string) => string

    Converts string to camelized class name. First letter is always upper case

    classify()("some_class_name");
    // => "SomeClassName"
     
    classify("some_class_name");
    // => "SomeClassName"

    underscored(string) => string

    Converts a camelized or dasherized string into an underscored one

    underscored()("MozTransform");
    // => "moz_transform"
     
    underscored("MozTransform");
    // => "moz_transform"

    dasherize(string) => string

    Converts a underscored or camelized string into an dasherized one

    dasherize()("MozTransform");
    // => "-moz-transform"
     
    dasherize("MozTransform");
    // => "-moz-transform"

    humanize(string) => string

    Converts an underscored, camelized, or dasherized string into a humanized one. Also removes beginning and ending whitespace, and removes the postfix '_id'.

    humanize()("  capitalize dash-CamelCase_underscore trim  ");
    // => "Capitalize dash camel case underscore trim"
     
    humanize("  capitalize dash-CamelCase_underscore trim  ");
    // => "Capitalize dash camel case underscore trim"

    trim(characters, string) => string

    Trims defined characters from begining and ending of the string.

    trim(' ')("  foobar   ");
    // => "foobar"
     
    trim("_-foobar-_", "_-");
    // => "foobar"

    ltrim(characters, string) => string

    Left trim. Similar to trim, but only for left side.

    rtrim(characters, string) => string

    Right trim. Similar to trim, but only for right side.

    truncate(truncateString, length, string) => string

    truncate('...')(5)("Hello world");
    // => "Hello..."
     
    truncate('...')(10)("Hello");
    // => "Hello"

    prune(pruneString, length, string) => string

    Elegant version of truncate. Makes sure the pruned string does not exceed the original length. Avoid half-chopped words when truncating.

    prune('...')(5)("Hello, world");
    // => "Hello..."
     
    prune('...')(8)("Hello, world");
    // => "Hello..."
     
    prune(" (read a lot more)")(5)("Hello, world");
    // => "Hello, world" (as adding "(read a lot more)" would be longer than the original string)
     
    prune( '...')(1)("Hello, cruel world");
    // => "Hello, cruel..."
     
    prune( '...')(1)("Hello");
    // => "Hello"

    words(str) => array

    Split string by /\s+/.

    words()("   I   love   you   ");
    // => ["I", "love", "you"]
     
    words("   ")
    // => []

    wordsDelim(delimiter=/\s+/, str) => array

    Split string by delimiter (String or RegExp).

    words("_")("I_love_you");
    // => ["I", "love", "you"]
     
    words(/-/)("I-love-you");
    // => ["I", "love", "you"]

    sprintf(arguments, string format) => string

    C like string formatting. Credits goes to Alexandru Marasteanu. For more detailed documentation, see the original page.

    sprintf(1.17)("%.1f");
    // => "1.2"

    pad(padStr, length, str) => string

    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 (" "). padStr is truncated to a single character if necessary.

    pad(" ")(8)("1");
    // => "       1"
     
    pad("0")(8)("1");
    // => "00000001"

    lpad(padStr, length, str) => string

    left-pad a string. Alias for pad(str, length, padStr, "left")

    lpad("0")(8)("1");
    // => "00000001"

    rpad(padStr, length, str) => string

    right-pad a string. Alias for pad(str, length, padStr, "right")

    rpad("0")(8)("1");
    // => "10000000"

    lrpad(padStr, length, str) => string

    left/right-pad a string. Alias for pad(str, length, padStr, "both")

    lrpad('0')(8)("1");
    // => "00001000"

    toNumber(decimals, string) => number

    Parse string to number. Returns NaN if string can't be parsed to number.

    toNumber(0)("2.556");
    // => 3
     
    toNumber(1)("2.556");
    // => 2.6
     
    toNumber(-1)("999.999");
    // => 990

    strRight(pattern, string) => string

    Searches a string from left to right for a pattern and returns a substring consisting of the characters in the string that are to the right of the pattern or all string if no match found.

    strRight("_")("This_is_a_test_string");
    // => "is_a_test_string"

    strRightBack(pattern, string) => string

    Searches a string from right to left for a pattern and returns a substring consisting of the characters in the string that are to the right of the pattern or all string if no match found.

    strRightBack("_")("This_is_a_test_string");
    // => "string"

    strLeft(pattern, string) => string

    Searches a string from left to right for a pattern and returns a substring consisting of the characters in the string that are to the left of the pattern or all string if no match found.

    strLeft("_")("This_is_a_test_string");
    // => "This";

    strLeftBack(pattern, string) => string

    Searches a string from right to left for a pattern and returns a substring consisting of the characters in the string that are to the left of the pattern or all string if no match found.

    strLeftBack("_")("This_is_a_test_string");
    // => "This_is_a_test";

    stripTags(string) => string

    Removes all html tags from string.

    stripTags()("a <a href="#">link</a>");
    // => "a link"
     
    stripTags("a <a href="#">link</a><script>alert("hello world!")</script>");
    // => "a linkalert("hello world!")"

    toSentence(lastDelimiter, delimiter, array) => string

    Join an array into a human readable sentence.

    toSentence(" and ")("")((["jQuery", "Mootools", "Prototype"]);
    // => "jQuery, Mootools and Prototype";
     
    toSentence(" unt ")("")((["jQuery", "Mootools", "Prototype"]);
    // => "jQuery, Mootools unt Prototype";

    toSentenceSerial(lastDelimiter, delimiter, array) => string

    The same as toSentence, but adjusts delimeters to use Serial comma.

    toSentenceSerial(' and ')('')(["jQuery", "Mootools"]);
    // => "jQuery and Mootools"
     
    toSentenceSerial(' and ')('')(["jQuery", "Mootools", "Prototype"]);
    // => "jQuery, Mootools, and Prototype"
     
    toSentenceSerial(' unt ')('')(["jQuery", "Mootools", "Prototype"]);
    // => "jQuery, Mootools, unt Prototype"

    repeat(separator, count, string) => string

    Repeats a string count times.

    repeat('')(3)("foo");
    // => "foofoofoo"
     
    repeat("bar")(3)("foo");
    // => "foobarfoobarfoo"

    surround(wrap, string) => string

    Surround a string with another string.

    surround("ab")("foo");
    // => "abfooab"

    quote(quoteChar, string) or q(quoteChar, string) => string

    Quotes a string. quoteChar.

    quote('"')("foo");
    // => '"foo"';

    unquote(quoteChar, string) => string

    Unquotes a string. quoteChar.

    unquote('"')('"foo"');
    // => "foo"
     
    unquote("'")("'foo'");
    // => "foo"

    slugify(string) => string

    Transform text into an ascii slug which can be used in safely in URLs. Replaces whitespaces, accentuated, and special characters with a dash. Limited set of non-ascii characters are transformed to similar versions in the ascii character set such as ä to a.

    slugify()("Un éléphant à l\'orée du bois");
    // => "un-elephant-a-l-oree-du-bois"
     
    slugify("Un éléphant à l\'orée du bois");
    // => "un-elephant-a-l-oree-du-bois"

    Caution: this function is charset dependent

    naturalCmp(string1, string2) => number

    Naturally sort strings like humans would do. None numbers are compared by their ASCII values. Note: this means "a" > "A". Use .toLowerCase if this isn't to be desired.

    Just past it to Array#sort.

    ["foo20", "foo5"].sort(naturalCmp);
    // => ["foo5", "foo20"]

    toBoolean(string) => boolean

    Turn strings that can be commonly considered as booleas to real booleans. Such as "true", "false", "1" and "0". This function is case insensitive.

    toBoolean("true");
    // => true
     
    toBoolean("FALSE");
    // => false
     
    toBoolean("random");
    // => undefined

    Library functions

    If you require the full library you can use composing and aliases

    s(functions) => function

    Compose new functions.

    var rockit = S(
      S.titleize(),
      S.insert('rocks', 9),
      S.trim('_')
    );
     
    // S.titleize(S.insert('rocks', 9, S.trim('_', "__stoeffel !__")));
    rockit("__stoeffel !__");
    // => "Stoeffel Rocks!"

    Aliases

    strip     = trim
    lstrip    = ltrim
    rstrip    = rtrim
    center    = lrpad
    rjust     = lpad
    ljust     = rpad
    contains  = include
    q         = quote
    toBool    = toBoolean
    camelcase = camelize

    Maintainers

    This library is maintained by

    Licence

    The MIT License

    Copyright (c) 2015 Christoph Hermann schtoeffel@gmail.com

    Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

    install

    npm i underscore.string.fp

    Downloadsweekly downloads

    8,789

    version

    1.0.4

    license

    none

    repository

    githubgithub

    last publish

    collaborators

    • avatar