Pure Utilities

Biblioteka zawierająca metody pomocnicze.

Instalacja

npm install pure-utilities

bash

array

average(array)

Zwraca średnią z elementów tablicy.

average(100, 200)
<= 150

comma(array, number)

Zwraca ciąg utworzony przez połączenie elementów tablicy przecinkiem i opcjonalnymi spacjami.

comma([1, 2, 3], 2)
<= "1,  2,  3"

compact(array, strict)

Zwraca tablicę, zawierającą tylko te elementy, których wartości są prawdziwe.

compact([0, 1, false, null, 2, "", 3])
<= [1,2,3]

compact([0, 1, null, 2, undefined, 3], false)
<= [0,1,2,3]

difference(array, arrays)

Zwraca tablicę, zawierającą elementy, które nie występują w pozostałych tablicach.

difference([1, 2, 3, 4, 5, 100], [100, 2, 3, 10, 31])
<= [1,4,5]

drop(array, digit)

Usuwa elementy z tablicy.

drop([1, 2, 3], 2)
<= [3]

duplicates(array)

Zwraca tablicę, zawierającą powtarzające się elementy.

duplicates([1, 1, 2, 3, 5, 5])
<= [1,5]

eigth(array)

Zwraca ósmy element tablicy.

eigth([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
<= 8

fifth(array)

Zwraca piąty element tablicy.

fifth([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
<= 5

first(array)

Zwraca pierwszy element tablicy.

first([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
<= 1

fourth(array)

Zwraca czwarty element tablicy.

fourth([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
<= 4

head(array)

Zwraca pierwszy element tablicy.

head([1, 2, 3, 4, 5, 6])
<= 1

identifier(array)

Zwraca unikalny identyfikator bazując na wykorzystanych identyfikatorach.

identifier(["a"])
<= "b"

intersection(arrays)

Zwraca tablicę, zawierającą elementy wspólne dla wszystkich tablic, które zostały przekazane do funkcji.

intersection([1, 2, 3, 4, 5, 100], [100, 2, 3, 10, 31])
<= [2,3,100]

last(array)

Zwraca ostatni element tablicy.

last([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
<= 10

median(array)

Zwraca medianę na podstawie wartości elementów tablicy.

median([6, 4, 2, 4, 4])
<= 4

ninth(array)

Zwraca dziewiąty element tablicy.

ninth([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
<= 9

nth(array, position)

Zwraca element znajdujący się na wybranej pozycji. Gdy parametr pozycji jest ujemny, wyszukiwanie elementu zaczyna się od końca tablicy.

nth([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 3)
<= 3

partition(array, predicate)

Zwraca tablicę elementów podzieloną na dwie grupy, pierwszą zawierającą elementy, dla których predykat zwraca prawdę oraz drugi, dla którego predykat zwraca fałsz. Predykat przyjmuje jeden argument.

partition([{ user: "barney", active: false }, { user: "fred", active: true }, { user: "pebbles", active: false }], item => item.active)
<= [[{"user":"fred","active":true}],[{"user":"barney","active":false},{"user":"pebbles","active":false}]]

pluck(array)

Zwraca listę wartości dla danej właściwości spośród listy obiektów.

pluck([{ foo: "bar"}, { name: "baz"}], "name")
<= ["baz"]

range(number, number)

Zwraca tablicę elementów z danego zakresu.

range(1, 5)
<= [1,2,3,4,5]

rotate(array, digit)

Przesuwa elementy tablicy. Jeśli drugi parametr jest ujemny, elementy są usuwane z końca tablicy i przenoszone na początek.

rotate([1, 2, 3], 2)
<= [3,1,2]

sample()

Zwraca losowy element tablicy.

sample([[1, 2, 3]])
<= 2

second(array)

Zwraca drugi element tablicy.

second([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
<= 2

seventh(array)

Zwraca siódmy element tablicy.

seventh([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
<= 7

sixth(array)

Zwraca szósty element tablicy.

sixth([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
<= 6

slice(array, start, end)

Wydobywa fragment tablicy.

slice([1, 2, 3, 4,5, 6], 3, 5)
<= [4,5]

sum(array)

Zwraca sumę elementów tablicy.

sum([3, 10, 2])
<= 15

symdifference(arrays)

Zwraca tablicę, zawierającą elementy, które nie należą do części wspólnej przekazanych tablic.

symdifference([1, 3, 4, 6, 7, 9], [3, 5, 6, 7, 8, 9])
<= [1,4,5,8]

take(array, digit)

Zwraca wybraną liczbę elementów tablicy na podstawie drugiego parametru, zaczynając od początku tablicy.

take([1, 2, 3, 4, 5, 6], 2)
<= [1,2]

tenth(array)

Zwraca dziesiąty element tablicy.

tenth([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
<= 10

third(array)

Zwraca trzeci element tablicy.

third([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
<= 3

union(arrays)

Zwraca tablicę unikalnych elementów.

union([2], [1, 2])
<= [2,1]

unique(array, iteratee)

Zwraca tablicę, zawierającą tylko unikatowe elementy.

unique([1, 1, 2, 10, 2, 33])
<= [1,2,10,33]

collection

append(collection, indefinite, amount, of, arguments)

Dodaje argumenty na końcu kolekcji.

append("foo", "bar")
<= "foobar"

append([1, 2, 3], 4, 5, 6)
<= [1,2,3,4,5,6]

flatten(collection)

Spłaszcza wielowymiarową tablicę lub wielokrotnie zagnieżdżony obiekt do jednowymiarowej tablicy lub płaskiego obiektu.

flatten([1, [2], [ [3, [ 4, [5] ] ] ] ])
<= [1,2,3,4,5]

flatten({"titles":{"index":"Buxus - Plants, seedlings, producer"}})
<= {"titles.index":"Buxus - Plants, seedlings, producer"}

occurences(collection, string)

Zwraca ilość wystąpień danego łańcucha znaków w kolekcji lub w innym łańcuchu znaków.

occurences(["foo", "foo", "bar"], "foo")
<= 2

occurences("foo foo bar", "foo")
<= 2

prepend(collection, indefinite, amount, of, arguments)

Dodaje argumenty na początku kolekcji.

prepend("foo", "bar")
<= "barfoo"

prepend([1, 2, 3], 4, 5, 6)
<= [4,5,6,1,2,3]

reverse(collection)

Odwraca kolejność elementów kolekcji.

reverse([1, 2, 3, 4])
<= [4,3,2,1]

reverse("foo")
<= "oof"

size(collection)

Zwraca liczbę elementów kolekcji.

size(1, 2, 3, 4, 5)
<= 5

size({ a: 1, b: 2 })
<= 2

unflatten(collection)

Konwertuje właściwości obiektu, których nazwy zawierają kropki(.), na zagnieżdżone obiety, zwracając obiekt o różnym stopniu głębokości.

unflatten({"errors.404.title":"Page not found"})
<= {"errors":{"404":{"title":"Page not found"}}}

date

day(date)

Zwraca dzień miesiąca (od 1 do 31) na podstawie przekazanej daty.

day(new Date(2018, 4, 28)
<= 28

format(date, format)

Formatuje datę. Pierwszy parametr może być obiektem typu Date lub łańcuchem znaków, z którego można utworzyć datę. Domyślnym formatem jest: YYYY-MM-DD.

format(new Date("2013/06/13"))
<= "13-06-2013"

format(new Date(2018, 4, 23), "MM")
<= "05"

format(new Date(2018, 4, 23), "DD/MM/YYYY")
<= "23/05/2018"

format(new Date("2013/06/09"))
<= "09-06-2013"

hours(date)

Zwraca godzinę (od 0 do 23) przekazanej daty.

hours(new Date(2018, 4, 28, 10))
<= 10

isostring(value)

Zwraca łańuch znaków w uproszczonym i rozszerzonym formacie ISO.

isostring("1460303444338")
<= "2016-04-10T15:50:44.338Z"

minutes(date)

Zwraca minutę danej godziny (od 0 do 59) przekazanej daty.

minutes(new Date(2018, 4, 28, 10, 11))
<= 11

month(date)

Zwraca miesiąc (od 0 do 11), na podstawie przekazanej daty.

month(new Date(2018, 4, 28))
<= 4

prettydate(date, localization)

Zwraca łańuch znaków, który zawiera: nazwę dnia tygodnia, dzień miesiąca (od 1 do 31), nazwę miesiąca oraz rok. Parametr "localization" może przyjąć wartość "en-En" lub "pl-Pl", w innym przypadku funkcja zwróci błąd. Domyślnie parametr "localization" przyjmuje wartość "en-En" i zwraca łańuch znaków w języku angielskim.

prettydate(new Date(2043, 9, 25))
<= "Sunday, 25th of October 2043"

prettydate(new Date(2018, 2, 21)
<= "Wednesday, 21st of March 2018"

prettydate(new Date(2018, 2, 21)
<= "środa, 21 marca 2018"

seconds(date)

Zwraca sekundę danej minuty (od 0 do 59) przekazanej daty.

seconds(new Date(2018, 4, 28, 10, 11, 12))
<= 12

timestamp(date, pattern)

Zwraca sformatowaną datę na podstawie przekazanego wzorca.

timestamp(new Date(2018, 4, 28), "YYYY")
<= "2018"

timestamp(new Date(2018, 4, 28), "YYYY/MM")
<= "2018/05"

timestamp(new Date(2018, 4, 28), "YYYY/MM/DD")
<= "2018/05/28"

weekday(date)

Zwraca dzień tygodnia (od 0 do 6) na podstawie przekazanej daty.

weekday(new Date(2017, 1, 11))
<= 6

year(date)

Zwraca rok na podstawie przekazanej daty.

year(new Date (2018, 4, 2))
<= 2018

json

prettify(value, indent)

Konwertuje wartość na zapis w formacie JSON. Gdy przekazana wartość nie jest łańcuchem tekstowym, zwraca niezmodyfikowaną wartość.

prettify({"foo":"bar"})
<= "{\n  \"foo\": \"bar\"\n}"

math

abs(number)

Zwraca wartość absolutną z liczby.

abs(-1)
<= 1

acos(number)

Zwraca arcus cosinus z liczby, wyrażony w radianach.

acos(0.5)
<= 1.0471975511965979

acosh(number)

Zwraca arcus cosinus hiperboliczny z liczby, wyrażony w radianach.

acosh(2)
<= 1.3169578969248166

add(number1, number2)

Dodaje dwa parametry.

add(10, 5)
<= 15

asin(number)

Zwraca arcus sinus z liczby, wyrażony w radianach.

asin(1)
<= 1.5707963267948966

asinh(number)

Zwraca arcus sinus hiperboliczny z liczby.

asinh(1)
<= 0.881373587019543

atan(number)

Zwraca arcus tanges hiperboliczny z liczby.

atan(1)
<= 0.7853981633974483

atan2(number1, number2)

Zwraca arcus tanges ilorazu argumentów przekazanych do funkcji.

atan2(5, 5)
<= 0.7853981633974483

atanh(number)

Zwraca arcus tanges hiperboliczny z liczby.

atanh(0.5)
<= 0.5493061443340548

cbrt(number)

Zwraca pierwiastek sześcienny z liczby.

cbrt(1)
<= 1

ceil(number)

Zwraca liczbę zaokrągloną w górę do najbliższej liczby całkowitej.

ceil(100.2)
<= 101

clamp(number, min, max)

Zwraca największą możliwą wartość z zakresu min-max uwzględniając przekazaną liczbę.

clamp(25, 20, 30)
<= 25

clamp(30, 20, 30)
<= 30

cos(number)

Zwraca cosinus z liczby (w radianach).

cos(1)
<= 0.5403023058681398

cosh(number)

Zwraca cosinus hiperboliczny z liczby.

cosh(0)
<= 1

cube(number)

Podnosi liczbę do potęgi 3.

cube(-4)
<= -64

decrement(number)

Dekrementuje liczbę.

decrement(1)
<= 0

degrees(number, precision)

Konwertuje radiany na stopnie. Rezultat domyślnie zaokrąglany jest do 2 miejsc po przecinku.

degrees(5)
<= 286.48

distance(a, b)

Oblicza odległość pomiędzy punktami a i b w przestrzeni.

distance([1,2,3], [1,2,4])
<= 1

divide(number1, number2)

Dzieli dwa parametry.

divide(10, 5)
<= 2

exp(number)

Zwraca wartość z wyrażenia E^number, gdzie E jest liczbę Eulera.

exp(0)
<= 1

factorial(number)

Zwraca silnię z liczby.

factorial(5)
<= 120

feet(number, precision, decimal)

Konwertuje cale na stopy. Domyślnie wynik zaokrąglany jest do 2 miejsc po przecinku. Gdy flaga "decimal" ustawiona jest jako fałsz, funkcja zwraca wynik jako łańcuch tekstowy z symoblem prim (′) na końcu.

feet(1)
<= 0.08

fixed(number, digit)

Formatuje liczbę używając notacji stałoprzecinkowej.

fixed(25.32)
<= "25"

float(number)

Przetwarza liczbę na liczbę zmiennoprzecinkową.

float("4.25")
<= 4.25

floor(number)

Zwraca liczbę zaokrągloną w dół do najbliższej liczby całkowitej.

floor(300.91)
<= 300

inches(number, precision, decimal)

Konwertuje stopy na cale. Domyślnie wynik zaokrąglany jest do 2 miejsc po przecinku. Gdy flaga "decimal" ustawiona jest jako fałsz, funkcja zwraca wynik jako łańcuch tekstowy z symoblem bis (″) na końcu.

inches(1)
<= 12

increment(number)

Inkrementuje liczbę.

increment(1)
<= 2

int(number)

Przetwarza liczbę na liczbę całkowitą.

int("4.25")
<= 4

kmeans(k, data, maxIterations)

Wylicza środki k klastrów, będących średnimi wartościami danych punktów.

kmeans(3, [[1,2],[2,3],[2,5],[1,6],[4,6],[3,5],[2,4],[4,3],[5,2],[6,9],[4,4],[3,3],[8,6],[7,5],[9,6],[9,7],[8,8],[7,9],[11,3],[11,2],[9,9],[7,8],[6,8],[12,2],[14,3],[15,1],[15,4],[14,2],[13,1],[16,4]])
<= {"centroids":[[7.6,7.5],[13.444444444444445,2.4444444444444446],[2.8181818181818183,3.909090909090909]],"iteration":4,"complete":true}

log(number)

Zwraca logarytm naturalny z liczby.

log(2, 8)
<= 0.6931471805599453

max(numbers)

Zwraca największą liczbę.

max([2,5,1])
<= 5

mean(array)

Wylicza średnią wartość zmiennych z tablicy.

mean([1,2,3,4])
<= 2.5

min(numbers)

Zwraca najmniejszą liczbę.

min([2,5,1])
<= 1

modulo(number1, number2)

Zwraca resztę z dzielenia dwóch parametrów.

modulo(7, 2)
<= 1

monetize(number, options)

Formatuje liczbę do formatu walutowego. Funkcja jako drugi argument przyjmuje obiekt konfiguracyjny z następującymi parametrami: - digits: Liczba cyfr po przecinku. Domyślnie 2. - separator: Separator oddzielający część dziesiętną od części całkowitej. Domyślnie ','. - symbol: Symbol waluty. Domyślnie 'zł'. - ending: Flaga booleowska, która określa czy symbol waluty znajduje się na końcu łańcucha znaków. Domyślnie ustawiona na true. - space: Flaga booleowska, która określa czy przed symbolem waluty powinna występować spacja. Domyślnie ustawiona na true. - hyphen: Symbol oddzielający grupy liczb całkowitych. Domyślnie ustawiony jako spacja. - size: Ilość liczb całkowitych, które powinny zostać zebrane w grupę. Domyślnie 3.

monetize(100)
<= "100,00 zł"

monetize(100.5, {"symbol":"€","separator":"."})
<= "100.50 €"

multiply(number1, number2)

Mnoży dwa parametry.

multiply(10, 5)
<= 50

percentage(number)

Konwertuje liczbę na format procentowy.

percentage(0.25)
<= "25%"

pow(number1, number2)

Zwraca wartość pierwszego parametru do potęgi drugiego parametru.

pow(2, 5)
<= 32

radians(number, precision)

Konwertuje stopnie na radiany. Rezultat domyślnie zaokrąglany jest do 2 miejsc po przecinku.

radians(12)
<= 0.21

random()

Zwraca zmiennoprzecinkową liczbę pseudolosową z przedziału 0-1.

random()
<= 0.17141045238163488

round(number)

Zaokrągla liczbę do najbliższej liczby całkowitej.

round(20.49)
<= 20

sin(number)

Zwraca sinus z liczby.

sin(2)
<= 0.9092974268256817

sinh(number)

Zwraca sinus hiperboliczny z liczby.

sinh(1)
<= 1.1752011936438014

sqrt(number)

Zwraca pierwiastek z liczby.

sqrt(4)
<= 2

square(number)

Zwraca kwadrat liczby.

square(5)
<= 25

subtract(number1, number2)

Odejmuje dwa parametry.

subtract(10, 5)
<= 5

tan(number)

Zwraca tanges z liczby.

tan(1)
<= 1.5574077246549023

tanh(number)

Zwraca tanges hiperboliczny z liczby.

tanh(-1)
<= -0.7615941559557649

trunc(number)

Zwraca część całkowitą z liczby.

trunc(42.84)
<= 42

object

camelcase(object)

Konwertuje klucze obiektu na camelCase.

camelcase({"created_at":"2000-01-01"})
<= {"createdAt":"2000-01-01"}

clone(object)

Tworzy płytką kopię przekazanego obiektu (obiekty są klonowane jako referencja).

clone({"a":0,"b":{"c":0}})
<= {"a":0,"b":{"c":0}}

deepclone(object)

Tworzy głęboką kopię przekazanego obiektu (obiekty są klonowane jako wartość).

deepclone({"a":0,"b":{"c":0}})
<= {"a":0,"b":{"c":0}}

dig(object, string)

Zwraca wartość dowolnej właściwości obiektu na podstawie przekazanego łańcucha znaków.

dig({"foo":{"bar":"baz"}}, "foo.bar")
<= "baz"

keys(object)

Zwraca tablicę zawierającą nazwy właściwości obiektu.

keys({"foo":"bar","baz":[1,2,3]})
<= ["foo","baz"]

merge(object, sources)

Scala właściwości obiektów źródłowych z obiektem docelowym.

merge({"foo":{"a":1,"b":1,"c":1},"baz":{"b":2,"c":2}})
<= {"foo":{"a":1,"b":1,"c":1},"baz":{"b":2,"c":2}}

merge({"foo":{"a":1,"b":1,"c":1},"baz":{"b":2,"c":2},"bar":{"c":3}})
<= {"foo":{"a":1,"b":1,"c":1},"baz":{"b":2,"c":2},"bar":{"c":3}}

pat(object, string, value)

Nadpisuje wartość właściwości, której nazwa została przekazana w parametrze string, na wartość przekazaną w parametrze value.

pat({"foo":"bar"}, "foo", "baz")
<= {"foo":"baz"}

recsort(object)

Sortuje klucze obiektu.

recsort({"b":2,"a":1})
<= {"a":1,"b":2}

rename(object, keys)

Zmienia nazwy właściwości obiektu na odpowiadające im wartości z obiektu keys.

rename({"created_at":"2000-01-01"}, {"created_at":"createdAt"})
<= {"createdAt":"2000-01-01"}

values(object)

Zwraca tablicę zawierającą własne, wyliczalne właściwości obiektu.

values({"foo":"bar","baz":[1,2,3]})
<= ["bar",[1,2,3]]

string

bytes(string)

Konwertuje łańcuch znaków z daną jednostką do bitów.

bytes("400KB")
<= 409600

camelize(string, lowercased)

Konwertuje łańcuch znaków do notacji camelcase. Drugi parametr określa konwersję pierwszej litery na małą lub dużą.

camelize("foo_bar")
<= "fooBar"

camelize("FooBar")
<= "fooBar"

capitalize(string)

Konwertuje pierwszą literę łańcucha znaków na dużą literę.

capitalize("foo")
<= "Foo"

capitalize("foo bar and baz")
<= "Foo bar and baz"

celsius(string)

Konwertuje temperaturę wyrażoną w stopniach Fahrenheita lub jednostkach Kelvina na stopnie Celsiusza. Gdy przekazany ciąg jest liczbą, dołącza ° C do ciągu.

celsius("25")
<= "25°C"

celsius("0°F")
<= "-18°C"

celsius("0K")
<= "-273°C"

chomp(string, pattern)

Usuwa podany wzorzec z końca łańcucha znaków.

chomp("foo bar", "ar")
<= "foo b"

chop(string)

Zwraca łańcuch tekstowy z usuniętym ostatnim znakiem. Jeśli łańcuch znaków kończy się znakami końca linii, to oba są usuwane.

chop("foo bar baz")
<= "foo bar ba"

classify(string)

Tworzy nazwę klasy na podstawie łańcucha znaków.

classify("cars")
<= "Car"

constantize(string)

Konwertuje łańcuch tekstowy do notacji constant.

constantize("foo")
<= "FOO"

crop(string, length, append)

Przycina łańcuch znaków do całych wyrazów. Dodaje ... jeśli łańcuch jest dłuższy niż drugi parametr.

crop("foo bar baz ban bar", 10)
<= "foo bar..."

dasherize(string)

Zamienia _ na -.

dasherize("foo_bar__baz")
<= "foo-bar--baz"

dot(string)

Zwraca łańcuch znaków z kropką na końcu.

dot("foo bar")
<= "foo bar."

fahrenheit(string)

Konwertuje temperaturę wyrażoną w stopniach Celsjusza lub jednostkach Kelvina na stopnie Fahrenheita. Gdy przekazany ciąg jest liczbą, dodaje ° F do ciągu.

fahrenheit("50")
<= "50°F"

fahrenheit("30°C")
<= "86°F"

htmlstrip(string)

Usuwa tagi HTML z podanego łańcucha znaków. Uwage: treści wysłane przez użytkowników mogą zawierać złośliwą zawartość, htmlstrip nie jest wystarczającym zabezpieczeniem przeciwko xss.

htmlstrip("<div>foo</div>")
<= "foo"

htmlstrip("Hello <b><i>world!</i></b>")
<= "Hello world!"

humanize(string, capitalize = true)

Zamienia _ na spacje. Gdy flaga capitalize ustawiona jest na true, konwertuje pierwszą literę łańcucha na dużą.

humanize("foo bar")
<= "Foo bar"

humanize("foo_bar")
<= "Foo bar"

hyphenate(string)

Zastępuje znak spacji myślnikami, oddziela znakiem myślnika wyrazy zapisane w notacji camelcase. Usuwa wyrazy niebędące słowami i konwertuje wszystkie litery na małe.

hyphenate("%# lorem ipsum  ? $  dolor")
<= "lorem-ipsum-dolor"

hyphenate("loremIpsum")
<= "lorem-ipsum"

index(string, pattern, start = 0)

Zwraca indeks szukanego wzorca.

index("hello", "e")
<= 1

index("hello", "lo")
<= 3

initials(string, separator = "")

Zwraca inicjały rozdzielone separatorem.

initials("Foo Bar")
<= "FB"

initials("Foo Barin-Bar", ".")
<= "F.B.B"

kelvin(string)

Konwertuje temperaturę wyrażoną w stopniach Fahrenheita lub Celsjusza, na skalę Kelvina. Gdy przekazany ciąg jest liczbą, dodaje K do ciągu.

kelvin("100")
<= "100K"

kelvin("26°C")
<= "299K"

lowercase(string)

Konwertuje litery na małe.

lowercase("Foo BAR and baZ")
<= "foo bar and baz"

lowerfirst(string)

Konwertuje pierwszą literę łańcucha znaków na małą literę.

lowerfirst("Foo bar baz")
<= "foo bar baz"

ltrim(string, characters = " ")

Usuwa białe znaki lub też inne określone w parametrze znaki od początku łańcucha znaków.

ltrim("   foo")
<= "foo"

pad(string, pad, left = true)

Zwraca łańcuch znaków z dodanym marginesem z lewej lub prawej strony.

pad("hello world", 5)
<= "     hello world"

pad("Hello world", 5, false)
<= "Hello world     "

pad("hello world", "** ")
<= "** hello world"

pluralize(string)

Zwraca liczbę mnogą danego łańcucha znaków.

pluralize("car")
<= "cars"

pluralize("dress")
<= "dresses"

pluralize("wife")
<= "wives"

quote(string, lang = "en")

Umieszcza łańcuch tekstowy w cudzysłowie.

quote("foo bar baz")
<= "\"foo bar baz\""

quote("foo bar baz", "pl")
<= "„foo bar baz”"

repeat(string, count)

Powiela łańcuch znaków okresloną ilość razy.

repeat("foo", 2)
<= "foofoo"

replace(string, pattern, replace)

Zastępuje szukany wzorzec ostatnim parametrem.

replace("foo bar baz ban", "baz", "qux")
<= "foo bar qux ban"

rtrim(string, characters = " ")

Usuwa białe znaki lub też inne określone w parametrze znaki od końca łańcucha znaków.

rtrim("foo   ")
<= "foo"

singlespace(string)

Zastępuje wielokrotne wystąpienia spacji w łańcuchu znaków na pojedyncze.

singlespace("foo     bar baz")
<= "foo bar baz"

singularize(string, appendix = "")

Zwraca liczbę pojedynczą danego łańcucha znaków.

singularize("cars")
<= "car"

singularize("watches")
<= "watch"

singularize("shelves", "f")
<= "shelf"

slugify(string, separator = "-")

Konwertuje litery łańcucha znaków na małe, usuwa wyrazy niebędące słowami, zastępuje spacje przekazanym do funkcji separatorem.

slugify("LoremIpsum dolor special chars")
<= "loremipsum-dolor-special-chars"

split(string, separator = "")

Dzieli łańcuch znaków na tablicę, dzieląc łańcuch znaków na części na podstawie separatora.

split("foo,bar,bazz", ",")
<= ["foo","bar","bazz"]

squeeze(string, pattern = "a-zA-Z")

Usuwa z łańcucha tekstowego wielokrotne wystąpienia tego samego znaku.

squeeze("yellow moon")
<= "yelow mon"

strip(string, pattern)

Usuwa przekazany wzorzec z łańcucha znaków.

strip(" foo ")
<= "foo"

strip("foo bar baz ban", ["o","r","a"])
<= "f b bz bn"

summarize(string, length = 100)

Dodaje trzy kropki na końcu łańcucha znaków, gdy ciąg jest dłuższy niż podana długość.

summarize("foo bar baz ban", 10)
<= "foo bar baz ban..."

swapcase(string)

Zamienia duże litery na małe, a małe na duże.

swapcase("foo")
<= "FOO"

swapcase("fOo Bar BAZ")
<= "FoO bAR baz"

tail(string, length = 30, ending = "...")

Skraca dany łańcuch tekstowy.

tail("Once upon a time in a world far far away", 15)
<= "...far far away"

titleize(string)

Konwertuje pierwszą literą każdego wyrazu na dużą.

titleize("foo bar")
<= "Foo Bar"

trim(string)

Usuwa spacje z początku i końca łańcucha znaków.

trim(" foo ")
<= "foo"

truncate(string, length = 30, ending = "...")

Skraca łańcuch tekstowy, jeśli jest dłuższy niż podana długość i dokleja w miejscu ucięcia ostatni parametr.

truncate("Once upon a time in a world far far away")
<= "Once upon a time in a world..."

truncate("Once upon a time in a world far far away", 15)
<= "Once upon a ..."

uid(length = 32)

Zwraca unikalny identyfikator.

uid(10)
<= "UbAEq3YKc5"

underscore(string)

Zwraca nowy łańcuch znaków, w którym wyrazy oddzielone są od siebie znakiem _. Wszystkie litery są konwertowane na małe.

underscore("fooBar")
<= "foo_bar"

unescape(string)

Konwertuje encje HTML na odpowiadające im znaki.

unescape("&amp;")
<= "&"

unquote(string)

Usuwa "" lub „” z łańcucha znaków.

unquote("„foo bar baz”")
<= "foo bar baz"

unquote("\"foo bar baz\"")
<= "foo bar baz"

unwrap(string, first, last = first)

Usuwa znaki z początku i końca łańcucha znaków na podstawie przekazanych parametrów.

unwrap("\"foo bar baz ban\"", "\"")
<= "foo bar baz ban"

unwrap("„foo bar baz”", "„", "”")
<= "foo bar baz"

uppercase(string)

Konwertuje znaki łańcucha na wielkie.

uppercase("foo")
<= "FOO"

whitespacestrip(string)

Usuwa spacje z łańcucha znaków.

whitespacestrip(" f o  o")
<= "foo"

wrap(string, first, last = first)

Umieszcza łańcuch znaków pomiędzy przekazanymi parametrami.

wrap("foo bar baz ban", "„", "”")
<= "„foo bar baz ban”"