StartNarzędziaJSPure Utilities

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
js

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"
js

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]
js
compact([0, 1, null, 2, undefined, 3], false)
<= [0,1,2,3]
js

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]
js

drop(array, digit)

Usuwa elementy z tablicy.

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

duplicates(array)

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

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

eigth(array)

Zwraca ósmy element tablicy.

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

fifth(array)

Zwraca piąty element tablicy.

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

first(array)

Zwraca pierwszy element tablicy.

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

fourth(array)

Zwraca czwarty element tablicy.

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

Zwraca pierwszy element tablicy.

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

identifier(array)

Zwraca unikalny identyfikator bazując na wykorzystanych identyfikatorach.

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

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]
js

last(array)

Zwraca ostatni element tablicy.

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

median(array)

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

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

ninth(array)

Zwraca dziewiąty element tablicy.

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

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
js

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}]]
js

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

range(number, number)

Zwraca tablicę elementów z danego zakresu.

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

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]
js

sample()

Zwraca losowy element tablicy.

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

second(array)

Zwraca drugi element tablicy.

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

seventh(array)

Zwraca siódmy element tablicy.

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

sixth(array)

Zwraca szósty element tablicy.

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

slice(array, start, end)

Wydobywa fragment tablicy.

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

sum(array)

Zwraca sumę elementów tablicy.

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

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]
js

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]
js

tenth(array)

Zwraca dziesiąty element tablicy.

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

third(array)

Zwraca trzeci element tablicy.

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

union(arrays)

Zwraca tablicę unikalnych elementów.

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

unique(array, iteratee)

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

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

collection


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

Dodaje argumenty na końcu kolekcji.

append("foo", "bar")
<= "foobar"
js
append([1, 2, 3], 4, 5, 6)
<= [1,2,3,4,5,6]
js

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]
js
flatten({"titles":{"index":"Buxus - Plants, seedlings, producer"}})
<= {"titles.index":"Buxus - Plants, seedlings, producer"}
js

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
js
occurences("foo foo bar", "foo")
<= 2
js

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

Dodaje argumenty na początku kolekcji.

prepend("foo", "bar")
<= "barfoo"
js
prepend([1, 2, 3], 4, 5, 6)
<= [4,5,6,1,2,3]
js

reverse(collection)

Odwraca kolejność elementów kolekcji.

reverse([1, 2, 3, 4])
<= [4,3,2,1]
js
reverse("foo")
<= "oof"
js

size(collection)

Zwraca liczbę elementów kolekcji.

size(1, 2, 3, 4, 5)
<= 5
js
size({ a: 1, b: 2 })
<= 2
js

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"}}}
js

date


day(date)

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

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

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"
js
format(new Date(2018, 4, 23), "MM")
<= "05"
js
format(new Date(2018, 4, 23), "DD/MM/YYYY")
<= "23/05/2018"
js
format(new Date("2013/06/09"))
<= "09-06-2013"
js

hours(date)

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

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

isostring(value)

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

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

minutes(date)

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

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

month(date)

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

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

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"
js
prettydate(new Date(2018, 2, 21)
<= "Wednesday, 21st of March 2018"
js
prettydate(new Date(2018, 2, 21)
<= "środa, 21 marca 2018"
js

seconds(date)

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

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

timestamp(date, pattern)

Zwraca sformatowaną datę na podstawie przekazanego wzorca.

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

weekday(date)

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

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

year(date)

Zwraca rok na podstawie przekazanej daty.

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

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}"
js

math


abs(number)

Zwraca wartość absolutną z liczby.

abs(-1)
<= 1
js

acos(number)

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

acos(0.5)
<= 1.0471975511965979
js

acosh(number)

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

acosh(2)
<= 1.3169578969248166
js

add(number1, number2)

Dodaje dwa parametry.

add(10, 5)
<= 15
js

asin(number)

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

asin(1)
<= 1.5707963267948966
js

asinh(number)

Zwraca arcus sinus hiperboliczny z liczby.

asinh(1)
<= 0.881373587019543
js

atan(number)

Zwraca arcus tanges hiperboliczny z liczby.

atan(1)
<= 0.7853981633974483
js

atan2(number1, number2)

Zwraca arcus tanges ilorazu argumentów przekazanych do funkcji.

atan2(5, 5)
<= 0.7853981633974483
js

atanh(number)

Zwraca arcus tanges hiperboliczny z liczby.

atanh(0.5)
<= 0.5493061443340548
js

cbrt(number)

Zwraca pierwiastek sześcienny z liczby.

cbrt(1)
<= 1
js

ceil(number)

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

ceil(100.2)
<= 101
js

clamp(number, min, max)

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

clamp(25, 20, 30)
<= 25
js
clamp(30, 20, 30)
<= 30
js

cos(number)

Zwraca cosinus z liczby (w radianach).

cos(1)
<= 0.5403023058681398
js

cosh(number)

Zwraca cosinus hiperboliczny z liczby.

cosh(0)
<= 1
js

cube(number)

Podnosi liczbę do potęgi 3.

cube(-4)
<= -64
js

decrement(number)

Dekrementuje liczbę.

decrement(1)
<= 0
js

degrees(number, precision)

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

degrees(5)
<= 286.48
js

distance(a, b)

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

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

divide(number1, number2)

Dzieli dwa parametry.

divide(10, 5)
<= 2
js

exp(number)

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

exp(0)
<= 1
js

factorial(number)

Zwraca silnię z liczby.

factorial(5)
<= 120
js

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
js

fixed(number, digit)

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

fixed(25.32)
<= "25"
js

float(number)

Przetwarza liczbę na liczbę zmiennoprzecinkową.

float("4.25")
<= 4.25
js

floor(number)

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

floor(300.91)
<= 300
js

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
js

increment(number)

Inkrementuje liczbę.

increment(1)
<= 2
js

int(number)

Przetwarza liczbę na liczbę całkowitą.

int("4.25")
<= 4
js

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}
js

log(number)

Zwraca logarytm naturalny z liczby.

log(2, 8)
<= 0.6931471805599453
js

max(numbers)

Zwraca największą liczbę.

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

mean(array)

Wylicza średnią wartość zmiennych z tablicy.

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

min(numbers)

Zwraca najmniejszą liczbę.

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

modulo(number1, number2)

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

modulo(7, 2)
<= 1
js

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ł"
js
monetize(100.5, {"symbol":"€","separator":"."})
<= "100.50 €"
js

multiply(number1, number2)

Mnoży dwa parametry.

multiply(10, 5)
<= 50
js

percentage(number)

Konwertuje liczbę na format procentowy.

percentage(0.25)
<= "25%"
js

pow(number1, number2)

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

pow(2, 5)
<= 32
js

radians(number, precision)

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

radians(12)
<= 0.21
js

random()

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

random()
<= 0.36955005165432175
js

round(number)

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

round(20.49)
<= 20
js

sin(number)

Zwraca sinus z liczby.

sin(2)
<= 0.9092974268256817
js

sinh(number)

Zwraca sinus hiperboliczny z liczby.

sinh(1)
<= 1.1752011936438014
js

sqrt(number)

Zwraca pierwiastek z liczby.

sqrt(4)
<= 2
js

square(number)

Zwraca kwadrat liczby.

square(5)
<= 25
js

subtract(number1, number2)

Odejmuje dwa parametry.

subtract(10, 5)
<= 5
js

tan(number)

Zwraca tanges z liczby.

tan(1)
<= 1.5574077246549023
js

tanh(number)

Zwraca tanges hiperboliczny z liczby.

tanh(-1)
<= -0.7615941559557649
js

trunc(number)

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

trunc(42.84)
<= 42
js

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}}
js

deepclone(object)

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

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

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"
js

keys(object)

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

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

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}}
js
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}}
js

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"}
js

recsort(object)

Sortuje klucze obiektu.

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

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"}
js

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]]
js

string


bytes(string)

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

bytes("400KB")
<= 409600
js

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"
js
camelize("FooBar")
<= "fooBar"
js

capitalize(string)

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

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

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"
js
celsius("0°F")
<= "-18°C"
js
celsius("0K")
<= "-273°C"
js

chomp(string, pattern)

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

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

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"
js

classify(string)

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

classify("cars")
<= "Car"
js

constantize(string)

Konwertuje łańcuch tekstowy do notacji constant.

constantize("foo")
<= "FOO"
js

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..."
js

dasherize(string)

Zamienia _ na -.

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

dot(string)

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

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

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"
js
fahrenheit("30°C")
<= "86°F"
js

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"
js
htmlstrip("Hello <b><i>world!</i></b>")
<= "Hello world!"
js

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"
js
humanize("foo_bar")
<= "Foo bar"
js

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"
js
hyphenate("loremIpsum")
<= "lorem-ipsum"
js

index(string, pattern, start = 0)

Zwraca indeks szukanego wzorca.

index("hello", "e")
<= 1
js
index("hello", "lo")
<= 3
js

initials(string, separator = "")

Zwraca inicjały rozdzielone separatorem.

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

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"
js
kelvin("26°C")
<= "299K"
js

lowercase(string)

Konwertuje litery na małe.

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

lowerfirst(string)

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

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

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"
js

pad(string, pad, left = true)

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

pad("hello world", 5)
<= " hello world"
js
pad("Hello world", 5, false)
<= "Hello world "
js
pad("hello world", "** ")
<= "** hello world"
js

pluralize(string)

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

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

quote(string, lang = "en")

Umieszcza łańcuch tekstowy w cudzysłowie.

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

repeat(string, count)

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

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

replace(string, pattern, replace)

Zastępuje szukany wzorzec ostatnim parametrem.

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

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"
js

singlespace(string)

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

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

singularize(string, appendix = "")

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

singularize("cars")
<= "car"
js
singularize("watches")
<= "watch"
js
singularize("shelves", "f")
<= "shelf"
js

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"
js

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

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

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

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

strip(string, pattern)

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

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

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..."
js

swapcase(string)

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

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

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"
js

titleize(string)

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

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

trim(string)

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

trim(" foo ")
<= "foo"
js

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..."
js
truncate("Once upon a time in a world far far away", 15)
<= "Once upon a ..."
js

uid(length = 32)

Zwraca unikalny identyfikator.

uid(10)
<= "vay7TsUerq"
js

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"
js

unescape(string)

Konwertuje encje HTML na odpowiadające im znaki.

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

unquote(string)

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

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

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"
js
unwrap("„foo bar baz”", "„", "”")
<= "foo bar baz"
js

uppercase(string)

Konwertuje znaki łańcucha na wielkie.

uppercase("foo")
<= "FOO"
js

whitespacestrip(string)

Usuwa spacje z łańcucha znaków.

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

wrap(string, first, last = first)

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

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