Характеристики

at(t(), integer()) :: grapheme() | nil

Возвращает графемную последовательность в position заданной UTF-8 string. Если position больше, чем длина string, то возвращает nil.

Примеры

iex> String.at("elixir", 0)
"e"

iex> String.at("elixir", 1)
"l"

iex> String.at("elixir", 10)
nil

iex> String.at("elixir", -1)
"r"

iex> String.at("elixir", -10)
nil

Характеристики

bag_distance(t(), t()) :: float()

Вычисляет расстояние по методу мешков между двумя строками.

Возвращает число с плавающей точкой от 0 до 1, представляющее расстояние по методу мешков между string1 и string2.

Расстояние по методу мешков предназначено для эффективного приближения расстояния между двумя строками, чтобы быстро исключить строки, которые сильно различаются.

Алгоритм описан в статье «String Matching with Metric Trees Using an Approximate Distance» авторов Илария Бартолини, Паоло Чиачча и Марко Пателла.

Примеры

iex> String.bag_distance("abc", "")
0.0
iex> String.bag_distance("abcd", "a")
0.25
iex> String.bag_distance("abcd", "ab")
0.5
iex> String.bag_distance("abcd", "abc")
0.75
iex> String.bag_distance("abcd", "abcd")
1.0

Характеристики

capitalize(t(), :default | :ascii | :greek) :: t()

Преобразует первый символ в заданной строке в верхний регистр, а оставшиеся символы — в нижний регистр в соответствии с mode.

mode может быть :default, :ascii или :greek. Режим :default учитывает все неявные преобразования, описанные в стандарте Unicode. Режим :ascii преобразует только буквы от A до Z в нижний регистр. Режим :greek включает контекстно-зависимые соответствия, найденные в греческом языке.

Примеры

iex> String.capitalize("abcd")
"Abcd"

iex> String.capitalize("fin")
"Fin"

iex> String.capitalize("olá")
"Olá"

Характеристики

chunk(t(), :valid | :printable) :: [t()]

Разбивает строку на фрагменты символов, обладающих общим признаком.

Признак может быть одним из двух вариантов:

• :valid — строка разбивается на фрагменты из последовательностей допустимых и недопустимых символов

• :printable — строка разбивается на фрагменты из последовательностей печатаемых и непечатаемых символов

Возвращает список бинарных данных, каждый из которых содержит только один тип символов.

Если заданная строка пуста, возвращается пустой список.

Примеры

iex> String.chunk(<<?a, ?b, ?c, 0>>, :valid)
["abc\0"]

iex> String.chunk(<<?a, ?b, ?c, 0, 0xFFFF::utf16>>, :valid)
["abc\0", <<0xFFFF::utf16>>]

iex> String.chunk(<<?a, ?b, ?c, 0, 0x0FFFF::utf8>>, :printable)
["abc", <<0, 0x0FFFF::utf8>>]

Характеристики

codepoints(t()) :: [codepoint()]

Возвращает все коды символов в строке.

Подробнее о кодах символов и графемах см. документацию модуля String.

Примеры

iex> String.codepoints("olá")
["o", "l", "á"]

iex> String.codepoints("оптими зации")
["о", "п", "т", "и", "м", "и", " ", "з", "а", "ц", "и", "и"]

iex> String.codepoints("ἅἪῼ")
["ἅ", "Ἢ", "ῼ"]

iex> String.codepoints("é")
["é"]

iex> String.codepoints("é")
["e", "́"]

Характеристики

contains?(t(), pattern()) :: boolean()

Проверяет, содержит ли string какие-либо из заданных contents.

contents может быть строкой, списком строк или скомпилированным шаблоном.

Примеры

iex> String.contains?("elixir of life", "of")
true
iex> String.contains?("elixir of life", ["life", "death"])
true
iex> String.contains?("elixir of life", ["death", "mercury"])
false

Аргумент также может быть скомпилированным шаблоном:

iex> pattern = :binary.compile_pattern(["life", "death"])
iex> String.contains?("elixir of life", pattern)
true

Пустая строка всегда будет совпадать:

iex> String.contains?("elixir of life", "")
true
iex> String.contains?("elixir of life", ["", "other"])
true

Обратите внимание, что эта функция может совпадать внутри или через графемные границы. Например, рассмотрим графемную последовательность «é», которая состоит из символов «e» и острого ударения. Следующее возвращает true:

iex> String.contains?(:unicode.characters_to_nfd_binary("é"), "e")
true

Однако, если «é» представлен одним символом «e с острым» ударением, то он вернет false:

iex> String.contains?(:unicode.characters_to_nfc_binary("é"), "e")
false

Характеристики

downcase(t(), :default | :ascii | :greek) :: t()

Преобразует все символы в заданной строке в нижний регистр в соответствии с mode.

mode может быть :default, :ascii или :greek. Режим :default учитывает все неявные преобразования, описанные в стандарте Unicode. Режим :ascii преобразует только буквы от A до Z в нижний регистр. Режим :greek включает контекстно-зависимые соответствия, найденные в греческом языке.

Примеры

iex> String.downcase("ABCD")
"abcd"

iex> String.downcase("AB 123 XPTO")
"ab 123 xpto"

iex> String.downcase("OLÁ")
"olá"

Режим :ascii игнорирует символы Unicode и обеспечивает более высокую производительность, когда известно, что строка содержит только символы ASCII:

iex> String.downcase("OLÁ", :ascii)
"olÁ"

И :greek правильно обрабатывает контекстно-зависимую сигму в греческом языке:

iex> String.downcase("ΣΣ")
"σσ"

iex> String.downcase("ΣΣ", :greek)
"σς"

Характеристики

duplicate(t(), non_neg_integer()) :: t()

Возвращает строку subject, дублированную n раз.

Встроен компилятором.

Примеры

iex> String.duplicate("abc", 0)
""

iex> String.duplicate("abc", 1)
"abc"

iex> String.duplicate("abc", 2)
"abcabc"

Характеристики

ends_with?(t(), t() | [t()]) :: boolean()

Возвращает true если string заканчивается любым из заданных суффиксов.

suffixes может быть как одиночным суффиксом, так и списком суффиксов.

Примеры

iex> String.ends_with?("language", "age")
true
iex> String.ends_with?("language", ["youth", "age"])
true
iex> String.ends_with?("language", ["youth", "elixir"])
false

Пустой суффикс всегда будет совпадать:

iex> String.ends_with?("language", "")
true
iex> String.ends_with?("language", ["", "other"])
true

Характеристики

equivalent?(t(), t()) :: boolean()

Возвращает true если string1 канонически эквивалентно 'строке2'.

Выполняет нормализацию формы канонического разложения (NFD) для строк перед их сравнением. Эта функция эквивалентна:

String.normalize(string1, :nfd) == String.normalize(string2, :nfd)

Поэтому, если вы планируете сравнивать несколько строк многократно, вы можете нормализовать их заранее и сравнивать их напрямую, чтобы избежать нескольких проходов нормализации.

Примеры

iex> String.equivalent?("abc", "abc")
true

iex> String.equivalent?("man\u0303ana", "mañana")
true

iex> String.equivalent?("abc", "ABC")
false

iex> String.equivalent?("nø", "nó")
false

Характеристики

first(t()) :: grapheme() | nil

Возвращает первый графемный символ из UTF-8 строки, nil если строка пустая.

Примеры

iex> String.first("elixir")
"e"

iex> String.first("եոգլի")
"ե"

Характеристики

graphemes(t()) :: [grapheme()]

Возвращает графемные последовательности в строке в соответствии с алгоритмом расширенного графемного кластера.

Алгоритм описан в Unicode Standard Annex #29, Unicode Text Segmentation.

Подробнее о кодах символов и графемах см. документацию модуля String.

Примеры

iex> String.graphemes("Ńaïve")
["Ń", "a", "ï", "v", "e"]

iex> String.graphemes("\u00e9")
["é"]

iex> String.graphemes("\u0065\u0301")
["é"]

Характеристики

jaro_distance(t(), t()) :: float()

Вычисляет расстояние по методу Джаро (подобие) между двумя строками.

Возвращает значение с плавающей точкой от 0.0 (равно нулевому сходству) до 1.0 (является точным совпадением), представляющее расстояние Джаро между string1 и string2.

Метрика расстояния Джаро разработана и наилучшим образом подходит для коротких строк, таких как имена людей. Сам Elixir использует эту функцию для предоставления функциональности «вы имели в виду?». Например, при вызове функции в модуле и наличии ошибки в имени функции, мы пытаемся предложить наиболее похожую доступную функцию, если таковая имеется, на основе оценки jaro_distance/2.

Примеры

iex> String.jaro_distance("Dwayne", "Duane")
0.8222222222222223
iex> String.jaro_distance("even", "odd")
0.0
iex> String.jaro_distance("same", "same")
1.0

Характеристики

last(t()) :: grapheme() | nil

Возвращает последний графемный символ из UTF-8 строки, nil если строка пустая.

Примеры

iex> String.last("elixir")
"r"

iex> String.last("եոգլի")
"ի"

Характеристики

length(t()) :: non_neg_integer()

Возвращает количество графем Unicode в строке UTF-8.

Примеры

iex> String.length("elixir")
6

iex> String.length("եոգլի")
5

Характеристики

match?(t(), Regex.t()) :: boolean()

Проверяет, соответствует ли string заданному регулярному выражению.

Примеры

iex> String.match?("foo", ~r/foo/)
true

iex> String.match?("bar", ~r/foo/)
false

Характеристики

myers_difference(t(), t()) :: [{:eq | :ins | :del, t()}]

Возвращает список ключевых слов, представляющих скрипт редактирования.

См. List.myers_difference/2 для получения дополнительной информации.

Примеры

iex> string1 = "fox hops over the dog"
iex> string2 = "fox jumps over the lazy cat"
iex> String.myers_difference(string1, string2)
[eq: "fox ", del: "ho", ins: "jum", eq: "ps over the ", del: "dog", ins: "lazy cat"]

Спецификации

next_codepoint(t()) :: {codepoint(), t()} | nil

Возвращает следующий код символа в строке.

Результат — кортеж с кодом символа и остальной частью строки или nil в случае, если строка достигла своего конца.

Как и другие функции в модуле String, next_codepoint/1 работает с двоичными данными, которые являются недопустимым UTF-8. Если строка начинается с последовательности байтов, которые не являются допустимыми в кодировке UTF-8, первый элемент возвращаемого кортежа — двоичные данные с первым байтом.

Примеры

iex> String.next_codepoint("olá")
{"o", "lá"}

iex> invalid = "\x80\x80OK" # first two bytes are invalid in UTF-8
iex> {_, rest} = String.next_codepoint(invalid)
{<<128>>, <<128, 79, 75>>}
iex> String.next_codepoint(rest)
{<<128>>, "OK"}

Сравнение с двоичным сопоставлением шаблонов

Двоичное сопоставление шаблонов предоставляет похожий способ разложить строку:

iex> <<codepoint::utf8, rest::binary>> = "Elixir"
"Elixir"
iex> codepoint
69
iex> rest
"lixir"

хотя и не полностью эквивалентно, потому что codepoint представлен как целое число, а шаблон не будет соответствовать недопустимому UTF-8.

Однако двоичное сопоставление шаблонов проще и эффективнее, поэтому выберите вариант, который лучше подходит для вашего случая использования.

Спецификации

next_grapheme(t()) :: {grapheme(), t()} | nil

Возвращает следующий графему в строке.

Результат — кортеж с графемой и остальной частью строки или nil в случае, если строка достигла своего конца.

Примеры

iex> String.next_grapheme("olá")
{"o", "lá"}

Спецификации

next_grapheme_size(t()) :: {pos_integer(), t()} | nil

Возвращает размер следующей графемы.

Результат — кортеж с размером следующей графемы и остальной частью строки или nil в случае, если строка достигла своего конца.

Примеры

iex> String.next_grapheme_size("olá")
{1, "lá"}

Преобразует все символы в string в форму нормализации Юникода, определённую form.

Формы

Поддерживаемые формы:

• :nfd — Форма нормализации каноническое разложение. Символы разлагаются по каноническому эквиваленту, и несколько комбинирующих символов упорядочиваются в определённом порядке.

• :nfc — Форма нормализации каноническое объединение. Символы разлагаются, а затем объединяются по каноническому эквиваленту.

Примеры

iex> String.normalize("yêṩ", :nfd)
"yêṩ"

iex> String.normalize("leña", :nfc)
"leña"

Спецификации

pad_leading(t(), non_neg_integer(), t() | [t()]) :: t()

Возвращает новую строку, заполненную ведущим заполнителем, состоящим из элементов из padding.

Передача списка строк в качестве padding возьмёт по одному элементу из списка для каждого отсутствующего элемента. Если список короче, чем количество вставляемых элементов, заполнение начнется снова с начала списка. Передача строки padding эквивалентна передаче списка графем в ней. Если padding не указано, оно по умолчанию равно пробелу.

Когда count меньше или равно длине string, возвращается string.

Вызывает ArgumentError, если заданный padding содержит элемент, не являющийся строкой.

Примеры

iex> String.pad_leading("abc", 5)
"  abc"

iex> String.pad_leading("abc", 4, "12")
"1abc"

iex> String.pad_leading("abc", 6, "12")
"121abc"

iex> String.pad_leading("abc", 5, ["1", "23"])
"123abc"

Спецификации

pad_trailing(t(), non_neg_integer(), t() | [t()]) :: t()

Возвращает новую строку, заполненную хвостовым заполнителем, состоящим из элементов из padding.

Передача списка строк в качестве padding возьмёт по одному элементу из списка для каждого отсутствующего элемента. Если список короче, чем количество вставляемых элементов, заполнение начнется снова с начала списка. Передача строки padding эквивалентна передаче списка графем в ней. Если padding не указано, оно по умолчанию равно пробелу.

Когда count меньше или равно длине string, возвращается string.

Вызывает ArgumentError, если заданный padding содержит элемент, не являющийся строкой.

Примеры

iex> String.pad_trailing("abc", 5)
"abc  "

iex> String.pad_trailing("abc", 4, "12")
"abc1"

iex> String.pad_trailing("abc", 6, "12")
"abc121"

iex> String.pad_trailing("abc", 5, ["1", "23"])
"abc123"

Спецификации

printable?(t(), 0) :: true

printable?(t(), pos_integer() | :infinity) :: boolean()

Проверяет, содержит ли строка только печатаемые символы до character_limit.

Принимает необязательный character_limit в качестве второго аргумента. Если character_limit равен 0, эта функция вернёт true.

Примеры

iex> String.printable?("abc")
true

iex> String.printable?("abc" <> <<0>>)
false

iex> String.printable?("abc" <> <<0>>, 2)
true

iex> String.printable?("abc" <> <<0>>, 0)
true

Спецификации

replace(t(), pattern() | Regex.t(), t() | (t() -> t() | iodata()), keyword()) ::
  t()

Возвращает новую строку, созданную путём замены вхождений pattern в subject на replacement.

subject — всегда строка.

pattern может быть строкой, регулярным выражением или скомпилированным шаблоном.

replacement может быть строкой или функцией, которая получает совпавший шаблон и должна вернуть замену как строку или iodata.

По умолчанию заменяются все вхождения, но это поведение можно контролировать с помощью опции :global; см. раздел «Опции» ниже.

Опции

• :global — (булево) если true, все вхождения pattern заменяются на replacement, в противном случае заменяется только первое вхождение. По умолчанию true

Примеры

iex> String.replace("a,b,c", ",", "-")
"a-b-c"

iex> String.replace("a,b,c", ",", "-", global: false)
"a-b,c"

Шаблон также может быть списком строк, а замена также может быть функцией, которая получает совпавшие шаблоны:

iex> String.replace("a,b,c", ["a", "c"], fn <<char>> -> <<char + 1>> end)
"b,b,d"

Когда шаблон является регулярным выражением, можно использовать \N или \g{N} в строке replacement для доступа к конкретному захвату в регулярном выражении:

iex> String.replace("a,b,c", ~r/,(.)/, ",\\1\\g{1}")
"a,bb,cc"

Обратите внимание, что нам пришлось экранировать обратную косую черту (т. е., мы использовали \\N вместо просто \N для экранирования обратной косой черты; то же самое для \\g{N}). Передав \0, можно вставить весь совпавший шаблон в строку замены.

Также можно указать скомпилированный шаблон:

iex> pattern = :binary.compile_pattern(",")
iex> String.replace("a,b,c", pattern, "[]")
"a[]b[]c"

Если в качестве pattern указана пустая строка, функция будет рассматривать её как неявную пустую строку между каждой графемой, и строка будет чередоваться. Если в качестве replacement указана пустая строка, то будет возвращено subject:

iex> String.replace("ELIXIR", "", ".")
".E.L.I.X.I.R."

iex> String.replace("ELIXIR", "", "")
"ELIXIR"

Спецификации

replace_leading(t(), t(), t()) :: t()

Заменяет все ведущие вхождения match на replacement из match в string.

Возвращает строку без изменений, если вхождений нет.

Если match является "", эта функция вызывает исключение ArgumentError: это происходит потому, что эта функция заменяет все вхождения match в начале string, и невозможно заменить «множественные» вхождения "".

Примеры

iex> String.replace_leading("hello world", "hello ", "")
"world"
iex> String.replace_leading("hello hello world", "hello ", "")
"world"

iex> String.replace_leading("hello world", "hello ", "ola ")
"ola world"
iex> String.replace_leading("hello hello world", "hello ", "ola ")
"ola ola world"

Спецификации

replace_prefix(t(), t(), t()) :: t()

Заменяет префикс в string на replacement, если он соответствует match.

Возвращает строку без изменений, если совпадения нет. Если match является пустой строкой (""), то replacement просто добавляется к string.

Примеры

iex> String.replace_prefix("world", "hello ", "")
"world"
iex> String.replace_prefix("hello world", "hello ", "")
"world"
iex> String.replace_prefix("hello hello world", "hello ", "")
"hello world"

iex> String.replace_prefix("world", "hello ", "ola ")
"world"
iex> String.replace_prefix("hello world", "hello ", "ola ")
"ola world"
iex> String.replace_prefix("hello hello world", "hello ", "ola ")
"ola hello world"

iex> String.replace_prefix("world", "", "hello ")
"hello world"

Спецификации

replace_suffix(t(), t(), t()) :: t()

Заменяет суффикс в string на replacement, если он соответствует match.

Возвращает строку без изменений, если совпадения нет. Если match является пустой строкой (""), replacement просто добавляется к string.

Примеры

iex> String.replace_suffix("hello", " world", "")
"hello"
iex> String.replace_suffix("hello world", " world", "")
"hello"
iex> String.replace_suffix("hello world world", " world", "")
"hello world"

iex> String.replace_suffix("hello", " world", " mundo")
"hello"
iex> String.replace_suffix("hello world", " world", " mundo")
"hello mundo"
iex> String.replace_suffix("hello world world", " world", " mundo")
"hello world mundo"

iex> String.replace_suffix("hello", "", " world")
"hello world"

Характеристики

replace_trailing(t(), t(), t()) :: t()

Заменяет все хвостовые вхождения match на replacement в string.

Возвращает строку без изменений, если вхождений нет.

Если match является "", эта функция генерирует исключение ArgumentError: это происходит потому, что эта функция заменяет все вхождения match в конце string, и невозможно заменить "несколько" вхождений "".

Примеры

iex> String.replace_trailing("hello world", " world", "")
"hello"
iex> String.replace_trailing("hello world world", " world", "")
"hello"

iex> String.replace_trailing("hello world", " world", " mundo")
"hello mundo"
iex> String.replace_trailing("hello world world", " world", " mundo")
"hello mundo mundo"

Характеристики

reverse(t()) :: t()

Инвертирует графемы в данной строке.

Примеры

iex> String.reverse("abcd")
"dcba"

iex> String.reverse("hello world")
"dlrow olleh"

iex> String.reverse("hello ∂og")
"go∂ olleh"

Обратите внимание, что повторное инвертирование одной и той же строки не обязательно приводит к исходной строке:

iex> "̀e"
"̀e"
iex> String.reverse("̀e")
"è"
iex> String.reverse(String.reverse("̀e"))
"è"

В первом примере ударение стоит перед гласной, поэтому оно считается двумя графемами. Однако при однократной инверсии вы получаете гласную, за которой следует ударение, что становится одной графемой. Повторное инвертирование сохранит её как одну графему.

Характеристики

slice(t(), Range.t()) :: t()

Возвращает подстроку от смещения, заданного началом диапазона, до смещения, заданного концом диапазона.

Если начало диапазона не является допустимым смещением для данной строки, или если диапазон упорядочен в обратном порядке, возвращает "".

Если начало или конец диапазона отрицательные, вся строка сперва просматривается для преобразования отрицательных индексов в положительные.

Помните, что эта функция работает с графемами Юникода и считает срезы как смещения графем. Если вам нужно разбить на сырые байты, проверьте Kernel.binary_part/3 вместо этого.

Примеры

iex> String.slice("elixir", 1..3)
"lix"

iex> String.slice("elixir", 1..10)
"lixir"

iex> String.slice("elixir", 10..3)
""

iex> String.slice("elixir", -4..-1)
"ixir"

iex> String.slice("elixir", 2..-1)
"ixir"

iex> String.slice("elixir", -4..6)
"ixir"

iex> String.slice("elixir", -1..-4)
""

iex> String.slice("elixir", -10..-7)
""

iex> String.slice("a", 0..1500)
"a"

iex> String.slice("a", 1..1500)
""

Характеристики

slice(t(), integer(), non_neg_integer()) :: grapheme()

Возвращает подстроку, начинающуюся со смещения start, и длиной len.

Если смещение больше длины строки, то возвращает "".

Помните, что эта функция работает с графемами Юникода и считает срезы как смещения графем. Если вам нужно разбить на сырые байты, проверьте Kernel.binary_part/3 вместо этого.

Примеры

iex> String.slice("elixir", 1, 3)
"lix"

iex> String.slice("elixir", 1, 10)
"lixir"

iex> String.slice("elixir", 10, 3)
""

iex> String.slice("elixir", -4, 4)
"ixir"

iex> String.slice("elixir", -10, 3)
""

iex> String.slice("a", 0, 1500)
"a"

iex> String.slice("a", 1, 1500)
""

iex> String.slice("a", 2, 1500)
""

Характеристики

split(t()) :: [t()]

Делит строку на подстроки в каждом вхождении пробела Юникода, при этом ведущие и хвостовые пробелы игнорируются. Группы пробелов обрабатываются как одно вхождение. Разделения не происходят на неразрывных пробелах.

Примеры

iex> String.split("foo bar")
["foo", "bar"]

iex> String.split("foo" <> <<194, 133>> <> "bar")
["foo", "bar"]

iex> String.split(" foo   bar ")
["foo", "bar"]

iex> String.split("no\u00a0break")
["no\u00a0break"]

Характеристики

split(t(), pattern() | Regex.t(), keyword()) :: [t()]

Делит строку на части по шаблону.

Возвращает список этих частей. Шаблон может быть строкой, списком строк, регулярным выражением или скомпилированным шаблоном.

Строка разделяется на максимально возможное количество частей по умолчанию, но это можно контролировать с помощью опции :parts.

Пустые строки удаляются из результата только в том случае, если опция :trim установлена в true.

При использовании в качестве шаблона регулярного выражения строка разбивается с помощью Regex.split/3.

Опции

• :parts (положительное целое число или :infinity)- строка разбивается не более чем на столько частей, сколько указано в этой опции. Если :infinity, строка будет разбита на все возможные части. По умолчанию :infinity.

• :trim (булево) - если true, пустые строки удаляются из результирующего списка.

Эта функция также принимает все опции, принимаемые Regex.split/3, если pattern является регулярным выражением.

Примеры

Разделение по шаблону-строке:

iex> String.split("a,b,c", ",")
["a", "b", "c"]

iex> String.split("a,b,c", ",", parts: 2)
["a", "b,c"]

iex> String.split(" a b c ", " ", trim: true)
["a", "b", "c"]

Список шаблонов:

iex> String.split("1,2 3,4", [" ", ","])
["1", "2", "3", "4"]

Регулярное выражение:

iex> String.split("a,b,c", ~r{,})
["a", "b", "c"]

iex> String.split("a,b,c", ~r{,}, parts: 2)
["a", "b,c"]

iex> String.split(" a b c ", ~r{\s}, trim: true)
["a", "b", "c"]

iex> String.split("abc", ~r{b}, include_captures: true)
["a", "b", "c"]

Скомпилированный шаблон:

iex> pattern = :binary.compile_pattern([" ", ","])
iex> String.split("1,2 3,4", pattern)
["1", "2", "3", "4"]

Разделение по пустой строке возвращает графемы:

iex> String.split("abc", "")
["", "a", "b", "c", ""]

iex> String.split("abc", "", trim: true)
["a", "b", "c"]

iex> String.split("abc", "", parts: 1)
["abc"]

iex> String.split("abc", "", parts: 3)
["", "a", "bc"]

Обратите внимание, что эта функция может разделять внутри или вне границ графем. Например, рассмотрите графему "é", которая состоит из символов "e" и острого ударения. Следующее разделит строку на две части:

iex> String.split(String.normalize("é", :nfd), "e")
["", "́"]

Однако, если "é" представлена одним символом "e с острым" ударением, то она разделит строку всего на одну часть:

iex> String.split(String.normalize("é", :nfc), "e")
["é"]

Характеристики

split_at(t(), integer()) :: {t(), t()}

Разбивает строку на две части по указанному смещению. При отрицательном смещении позиция считается с конца строки.

Смещение ограничено длиной строки. Возвращает кортеж из двух элементов.

Примечание: помните, что эта функция разбивает по графемам, и для этого ей необходимо линейно пройтись по строке. Если вам нужно разбить строку или двоичное представление по количеству байтов, используйте Kernel.binary_part/3 вместо этого.

Примеры

iex> String.split_at("sweetelixir", 5)
{"sweet", "elixir"}

iex> String.split_at("sweetelixir", -6)
{"sweet", "elixir"}

iex> String.split_at("abc", 0)
{"", "abc"}

iex> String.split_at("abc", 1000)
{"abc", ""}

iex> String.split_at("abc", -1000)
{"", "abc"}

Характеристики

splitter(t(), pattern(), keyword()) :: Enumerable.t()

Возвращает перечисляемый объект, который по требованию разбивает строку.

В отличие от split/3, который разбивает всю строку сразу.

Эта функция не поддерживает регулярные выражения по своему дизайну. При использовании регулярных выражений часто более эффективно заставить регулярные выражения проходить по строке сразу, чем по частям, как это делает эта функция.

Опции

• :trim - когда true, не выводит пустые шаблоны

Примеры

iex> String.splitter("1,2 3,4 5,6 7,8,...,99999", [" ", ","]) |> Enum.take(4)
["1", "2", "3", "4"]

iex> String.splitter("abcd", "") |> Enum.take(10)
["", "a", "b", "c", "d", ""]

iex> String.splitter("abcd", "", trim: true) |> Enum.take(10)
["a", "b", "c", "d"]

Также можно передать скомпилированный шаблон:

iex> pattern = :binary.compile_pattern([" ", ","])
iex> String.splitter("1,2 3,4 5,6 7,8,...,99999", pattern) |> Enum.take(4)
["1", "2", "3", "4"]

Характеристики

starts_with?(t(), pattern()) :: boolean()

Возвращает true если string начинается с любого из заданных префиксов.

prefix может быть строкой, списком строк или скомпилированным шаблоном.

Примеры

iex> String.starts_with?("elixir", "eli")
true
iex> String.starts_with?("elixir", ["erlang", "elixir"])
true
iex> String.starts_with?("elixir", ["erlang", "ruby"])
false

Также можно передать скомпилированный шаблон:

iex> pattern = :binary.compile_pattern(["erlang", "elixir"])
iex> String.starts_with?("elixir", pattern)
true

Пустая строка всегда будет соответствовать:

iex> String.starts_with?("elixir", "")
true
iex> String.starts_with?("elixir", ["", "other"])
true

Характеристики

to_atom(String.t()) :: atom()

Преобразует строку в атом.

Предупреждение: эта функция создаёт атомы динамически, и атомы не собираются сборщиком мусора. Поэтому string не должно быть недоверенным значением, например, входными данными, полученными из сокета или во время веб-запроса. Рассмотрите использование to_existing_atom/1 вместо этого.

По умолчанию максимальное количество атомов равно 1_048_576. Этот предел можно увеличить или уменьшить, используя параметр VM +t.

Максимальный размер атома составляет 255 точек кода Юникода.

Встраивается компилятором.

Примеры

iex> String.to_atom("my_atom")
:my_atom

Характеристики

to_charlist(t()) :: charlist()

Преобразует строку в список символов.

Конкретно, эта функция принимает UTF-8 закодированный двоичный массив и возвращает список его целых точек кода. Она аналогична codepoints/1, за исключением того, что последняя возвращает список точек кода в виде строк.

Если вам нужно работать с байтами, обратите внимание на :binary модуль.

Примеры

iex> String.to_charlist("æß")
'æß'

Характеристики

to_existing_atom(String.t()) :: atom()

Преобразует строку в существующий атом.

Максимальный размер атома составляет 255 точек кода Юникода.

Встраивается компилятором.

Примеры

iex> _ = :my_atom
iex> String.to_existing_atom("my_atom")
:my_atom

iex> String.to_existing_atom("this_atom_will_never_exist")
** (ArgumentError) argument error

Характеристики

to_float(String.t()) :: float()

Возвращает число с плавающей запятой, текстовое представление которого string.

string должно быть текстовым представлением числа с плавающей запятой, включая десятичную точку. Чтобы разобрать строку без десятичной точки как число с плавающей точкой, необходимо использовать Float.parse/1. В противном случае будет вызвано исключение ArgumentError.

Встраивается компилятором.

Примеры

iex> String.to_float("2.2017764e+0")
2.2017764

iex> String.to_float("3.0")
3.0

String.to_float("3")
#=> ** (ArgumentError) argument error

Характеристики

to_integer(String.t()) :: integer()

Возвращает целое число, текстовое представление которого string.

string должна быть строковым представлением целого числа. В противном случае будет поднято исключение ArgumentError. Если вы хотите проанализировать строку, которая может содержать некорректно отформатированное целое число, используйте Integer.parse/1.

Встроен компилятором.

Примеры

iex> String.to_integer("123")
123

Передача строки, которая не представляет целое число, приводит к ошибке:

String.to_integer("invalid data")
#=> ** (ArgumentError) argument error

Характеристики

to_integer(String.t(), 2..36) :: integer()

Возвращает целое число, текстовое представление которого string в основании base.

Встроен компилятором.

Примеры

iex> String.to_integer("3FF", 16)
1023

Характеристики

trim(t()) :: t()

Возвращает строку, из которой удалены все начальные и конечные пробелы Unicode.

Примеры

iex> String.trim("\n  abc\n  ")
"abc"

Характеристики

trim(t(), t()) :: t()

Возвращает строку, из которой удалены все начальные и конечные символы to_trim.

Примеры

iex> String.trim("a  abc  a", "a")
"  abc  "

Характеристики

trim_leading(t()) :: t()

Возвращает строку, из которой удалены все начальные пробелы Unicode.

Примеры

iex> String.trim_leading("\n  abc   ")
"abc   "

Характеристики

trim_leading(t(), t()) :: t()

Возвращает строку, из которой удалены все начальные символы to_trim.

Примеры

iex> String.trim_leading("__ abc _", "_")
" abc _"

iex> String.trim_leading("1 abc", "11")
"1 abc"

Характеристики

trim_trailing(t()) :: t()

Возвращает строку, из которой удалены все конечные пробелы Unicode.

Примеры

iex> String.trim_trailing("   abc\n  ")
"   abc"

Характеристики

trim_trailing(t(), t()) :: t()

Возвращает строку, из которой удалены все конечные символы to_trim.

Примеры

iex> String.trim_trailing("_ abc __", "_")
"_ abc "

iex> String.trim_trailing("abc 1", "11")
"abc 1"

Характеристики

upcase(t(), :default | :ascii | :greek) :: t()

Преобразует все символы в заданной строке в верхний регистр в соответствии с mode.

mode может быть :default, :ascii или :greek. Режим :default учитывает все неявные преобразования, описанные в стандарте Unicode. Режим :ascii преобразует только буквы от a до z в верхний регистр. Режим :greek включает контекстно-зависимые отображения, найденные в греческом языке.

Примеры

iex> String.upcase("abcd")
"ABCD"

iex> String.upcase("ab 123 xpto")
"AB 123 XPTO"

iex> String.upcase("olá")
"OLÁ"

Режим :ascii игнорирует символы Unicode и предоставляет более производительную реализацию, когда известно, что строка содержит только символы ASCII:

iex> String.upcase("olá", :ascii)
"OLá"

Характеристики

valid?(t()) :: boolean()

Проверяет, содержит ли string только допустимые символы.

Примеры

iex> String.valid?("a")
true

iex> String.valid?("ø")
true

iex> String.valid?(<<0xFFFF::16>>)
false

iex> String.valid?(<<0xEF, 0xB7, 0x90>>)
true

iex> String.valid?("asd" <> <<0xFFFF::16>>)
false