Pure Utilities

Biblioteka zawierająca metody pomocnicze.

Instalacja

npm install pure-utilities

Array


average  (array)

Zwraca średnią z elementów tablicy.

average(100, 200)
<= 150

comma  (array, number)

Zwraca łańcuch znaków zawierający dodatkowe przecincki i opcjonalne spacje.

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 wybraną liczbę elementów z tablicy.

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

duplicates  (array)

Zwraca tablicę, zawierającą powtarzające sie 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

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 "position" 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"]

rotate  (array, digit)

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

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

sample  ()

Zwraca losowy element tablicy.

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

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ę z unikalnymi wartościami.

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

unique  (array)

Zwraca tablicę, zawierające tylko unikatowe elementy.

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

Collection


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

Dodaje argumenty na koniec 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 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ątek 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 24) przekazanej daty.

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

isostring  (value)

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

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

minutes  (date)

Zwraca minutę danej godziny (od 0 do 60) 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 60) 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.

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

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

log  (number)

Zwraca logarytm naturalny z liczby.

log(2, 8)
<= 0.6931471805599453

max  (numbers)

Zwraca wartość wartość maksymalną z tablicy liczb.

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

mean  (array)

Wylicza średnią wartość zmiennych z tablicy.

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

min  (numbers)

Zwraca wartość minimalną z tablicy 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ńcuha znaków. Domyślnie ustawiona na true. - space: Flaga booleowska, która określa czy przed symbole waluty powinna występować spacja. Domyślnie ustawiona na true. - hyphen: Symbol oddzielający grupy liczb całkowitych. Domyślnie ustawiony jako spacja. - size: Liczba, liczb całkowitych, które powinny zostać zebranę 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)

Podnosi pierwszy parametr 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 liczbę pseudolosową z przedziału 0-1.

random()
<= 0.1868074987830053

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


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 wielką 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.

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 string 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.

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

htmlstrip  (string)

Usuwa tagi HTML z podanego łańcucha znaków. Uwaga: nie należy stosować jako mechanizmu zabezpieczającego.

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 wielką.

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.

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ą rzeczownika.

pluralize("car")
<= "cars"
pluralize("dress")
<= "dresses"
pluralize("wife")
<= "wives"

quote  (string, lang = "en")

Umieszcza łańcuch tekstowy w cudzysłowiu.

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 podany wzorzec nowym łańcuchem znaków.

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 na pojedyncze.

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

singularize  (string, appendix = "")

Zwraca liczbę pojedynczą rzeczownika.

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 wielką.

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 = "...")

Ucina ł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)
<= "8iBH3Vq4rj"

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 litery 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”"