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

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.

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

Алгоритм описан в статье «Сопоставление строк с помощью метрических деревьев с использованием приближенного расстояния» авторов Иларии Бартолини, Паоло Чиаччи и Марко Пателла.

Примеры

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?(String.normalize("é", :nfd), "e")
true

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

iex> String.contains?(String.normalize("é", :nfc), "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 в строке в соответствии с алгоритмом расширенного графема.

Алгоритм описан в 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.

Невалидные коды Юникода пропускаются, и оставшаяся часть строки преобразуется. Если вы хотите, чтобы алгоритм останавливался и возвращался при обнаружении невалидного кода, используйте :unicode.characters_to_nfd_binary/1 и :unicode.characters_to_nfc_binary/1.

Формы

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

• :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 - (boolean) если 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 в конце строки string на replacement.

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

Если 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(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(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(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(t()) :: integer()

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

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

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

Примеры

iex> String.to_integer("123")
123

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

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

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

to_integer(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