Spec-Zone.ru › OCaml 4.14

Модуль Строки

module String: sig .. end

Строки.

Строка s длины n — это индексируемая и неизменяемая последовательность n байт. По историческим причинам эти байты называются символами.

Семантика функций строк определяется в терминах индексов и позиций. Они изображены и описаны следующим образом.

positions  0   1   2   3   4    n-1    n
           +---+---+---+---+     +-----+
  indices  | 0 | 1 | 2 | 3 | ... | n-1 |
           +---+---+---+---+     +-----+
  • Индекс i строки s — целое число в диапазоне [0;n-1]. Он представляет iй байт (символ) строки s, к которому можно получить доступ с использованием оператора индексирования строк за постоянное время s.[i].
  • Позиция i строки s — целое число в диапазоне [0;n]. Она представляет либо начало строки, либо точку между двумя индексами, либо конец строки. i-й индекс байта находится между позициями i и i+1.

Два целых числа start и len определяют допустимый подстроку строки s если len >= 0 и start, start+len являются позициями строки s.

Текст Юникод. Так как строки являются произвольными последовательностями байтов, они могут содержать любые типы кодировок текста. Однако рекомендуемой кодировкой для хранения текстовых данных Юникод в строках OCaml является UTF-8. Эта кодировка используется для представления юникод-эскейпов в строковых литералах. Например, строка "\u{1F42B}" представляет UTF-8 кодировку символа Юникод U+1F42B.

Прежняя изменяемость. Раньше строки OCaml могли изменяться на месте, например, с помощью функций String.set и String.blit. Сейчас это возможно только когда компилятор находится в режиме "unsafe-string", используя опцию командной строки -unsafe-string. Этот режим совместимости делает типы string и bytes (см. Bytes.t) взаимозаменяемыми, так что функции, ожидающие последовательности байтов, также могут принимать строки в качестве аргументов и изменять их.

Различие между bytes и string было введено в OCaml 4.02, а режим совместимости "unsafe-string" был по умолчанию до OCaml 4.05. Начиная с версии 4.06, режим совместимости включён по выбору; в будущем мы планируем убрать эту опцию.

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

Строки

type t = string

Тип для строк.

val make : int -> char -> string

make n c — это строка длины n с каждым индексом, содержащим символ c.

  • Возбуждает Invalid_argument если n < 0 или n > Sys.max_string_length.
val init : int -> (int -> char) -> string

init n f — это строка длины n с индексом i, содержащим символ f i (в порядке возрастания индексов).

  • С 4.02.0
  • Возбуждает Invalid_argument если n < 0 или n > Sys.max_string_length.
val empty : string

Пустая строка.

  • С 4.13.0
val of_bytes : bytes -> string

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

  • С 4.13.0
val to_bytes : string -> bytes

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

  • С 4.13.0
val length : string -> int

length s — это длина (количество байтов/символов) строки s.

val get : string -> int -> char

get s i — это символ с индексом i в строке s. Это то же самое, что s.[i].

  • Возбуждает Invalid_argument если i не является индексом строки s.

Конкатенация

Примечание. Бинарный оператор (^) конкатенирует две строки.

val concat : string -> string list -> string

concat sep ss конкатенирует список строк ss, вставляя разделительную строку sep между каждой.

  • Возбуждает Invalid_argument если результат длиннее, чем Sys.max_string_length байт.
val cat : string -> string -> string

cat s1 s2 конкатенирует s1 и s2 (s1 ^ s2).

  • С 4.13.0
  • Возбуждает Invalid_argument если результат длиннее, чем Sys.max_string_length байт.

Предикаты и сравнения

val equal : t -> t -> bool

equal s0 s1 равно true тогда и только тогда, когда s0 и s1 равны посимвольно.

  • С 4.03.0 (4.05.0 в StringLabels)
val compare : t -> t -> int

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

val starts_with : prefix:string -> string -> bool

starts_with ~prefix s является true тогда и только тогда, когда s начинается со строки prefix.

  • С 4.13.0
val ends_with : suffix:string -> string -> bool

ends_with suffix s является true тогда и только тогда, когда s заканчивается на строке suffix.

  • С 4.13.0
val contains_from : string -> int -> char -> bool

contains_from s start c является true тогда и только тогда, когда c появляется в s после позиции start.

  • Возбуждает Invalid_argument если start не является допустимой позицией в строке s.
val rcontains_from : string -> int -> char -> bool

rcontains_from s stop c является true тогда и только тогда, когда c появляется в s перед позицией stop+1.

  • Возбуждает Invalid_argument если stop < 0 или stop+1 не являются допустимыми позициями в строке s.
val contains : string -> char -> bool

contains s c — это String.contains_from s 0 c.

Извлечение подстрок

val sub : string -> int -> int -> string

sub s pos len — это строка длины len, содержащая подстроку строки s, которая начинается с позиции pos и имеет длину len.

  • Возбуждает Invalid_argument если pos и len не обозначают допустимую подстроку в строке s.
val split_on_char : char -> string -> string list

split_on_char sep s — это список всех (возможно пустых) подстрок строки s, ограниченных символом sep.

Результат функции задаётся следующими инвариантами:

  • Список не пуст.
  • Конкатенация его элементов с использованием разделителя sep возвращает строку, равную входной строке (concat (make 1 sep)
          (split_on_char sep s) = s    ).
  • Ни одна из строк в результате не содержит символ sep.
  • С 4.04.0 (4.05.0 в StringLabels)

Преобразование

val map : (char -> char) -> string -> string

map f s — это строка, полученная путём применения f ко всем символам строки s в порядке возрастания индексов.

  • С 4.00.0
val mapi : (int -> char -> char) -> string -> string

mapi f s — это как String.map, но функция f также получает индекс символа.

  • С 4.02.0
val fold_left : ('a -> char -> 'a) -> 'a -> string -> 'a

fold_left f x s вычисляет f (... (f (f x s.[0]) s.[1]) ...) s.[n-1], где n — длина строки s.

  • С 4.13.0
val fold_right : (char -> 'a -> 'a) -> string -> 'a -> 'a

fold_right f s x вычисляет f s.[0] (f s.[1] ( ... (f s.[n-1] x) ...)), где n — длина строки s.

  • С 4.13.0
val for_all : (char -> bool) -> string -> bool

for_all p s проверяет, удовлетворяют ли все символы в строке s предикату p.

  • С 4.13.0
val exists : (char -> bool) -> string -> bool

exists p s проверяет, удовлетворяет ли хотя бы один символ в строке s предикату p.

  • С 4.13.0
val trim : string -> string

trim s — это s без начальных и конечных пробелов. Символы пробелов: ' ', '\x0C' (форма подачи), '\n', '\r', и '\t'.

  • Since 4.00.0
val escaped : string -> string

escaped s — это s со специальными символами, представленными последовательностями экранирования, следующими лексическим соглашениям OCaml.

Все символы за пределами печатаемого диапазона US-ASCII [0x20;0x7E], а также обратная косая черта (0x2F) и двойная кавычка (0x22) экранируются.

Функция Scanf.unescaped является левым обратным элементом escaped, т.е. Scanf.unescaped (escaped s) = s для любой строки s (если escaped s не потерпит неудачу).

  • Raises Invalid_argument если результат длиннее, чем Sys.max_string_length байтов.
val uppercase_ascii : string -> string

uppercase_ascii s — это s со всеми строчными буквами, преобразованными в прописные, с использованием набора символов US-ASCII.

  • Since 4.03.0 (4.05.0 в StringLabels)
val lowercase_ascii : string -> string

lowercase_ascii s — это s со всеми прописными буквами, преобразованными в строчные, с использованием набора символов US-ASCII.

  • Since 4.03.0 (4.05.0 в StringLabels)
val capitalize_ascii : string -> string

capitalize_ascii s — это s с первой буквой, преобразованной в прописную, с использованием набора символов US-ASCII.

  • Since 4.03.0 (4.05.0 в StringLabels)
val uncapitalize_ascii : string -> string

uncapitalize_ascii s — это s с первой буквой, преобразованной в строчную, с использованием набора символов US-ASCII.

  • Since 4.03.0 (4.05.0 в StringLabels)

Перебор

val iter : (char -> unit) -> string -> unit

iter f s применяет функцию f поочередно ко всем символам s. Это эквивалентно f s.[0]; f s.[1]; ...; f s.[length s - 1]; ().

val iteri : (int -> char -> unit) -> string -> unit

iteri подобно String.iter, но функция также получает соответствующий индекс символа.

  • Since 4.00.0

Поиск

val index_from : string -> int -> char -> int

index_from s i c — это индекс первого вхождения c в s после позиции i.

  • Raises
    • Not_found если c не встречается в s после позиции i.
    • Invalid_argument если i не является допустимой позицией в s.
val index_from_opt : string -> int -> char -> int option

index_from_opt s i c — это индекс первого вхождения c в s после позиции i (если таковое имеется).

  • Since 4.05
  • Raises Invalid_argument если i не является допустимой позицией в s.
val rindex_from : string -> int -> char -> int

rindex_from s i c — это индекс последнего вхождения c в s перед позицией i+1.

  • Raises
    • Not_found если c не встречается в s перед позицией i+1.
    • Invalid_argument если i+1 не является допустимой позицией в s.
val rindex_from_opt : string -> int -> char -> int option

rindex_from_opt s i c — это индекс последнего вхождения c в s перед позицией i+1 (если таковое имеется).

  • Since 4.05
  • Raises Invalid_argument если i+1 не является допустимой позицией в s.
val index : string -> char -> int

index s c — это String.index_from s 0 c.

val index_opt : string -> char -> int option

index_opt s c — это String.index_from_opt s 0 c.

  • Since 4.05
val rindex : string -> char -> int

rindex s c — это String.rindex_from s (length s - 1) c.

val rindex_opt : string -> char -> int option

rindex_opt s c — это String.rindex_from_opt s (length s - 1) c.

  • Since 4.05

Строки и Последовательности

val to_seq : t -> char Seq.t

to_seq s — это последовательность, составленная из символов строки в порядке возрастания. В режиме "unsafe-string", изменения строки во время итерации будут отражаться в последовательности.

  • Since 4.07
val to_seqi : t -> (int * char) Seq.t

to_seqi s подобно String.to_seq, но также возвращает кортеж с соответствующим индексом.

  • Since 4.07
val of_seq : char Seq.t -> t

of_seq s — это строка, составленная из символов последовательности.

  • Since 4.07

Декодирование и валидация UTF

UTF-8

val get_utf_8_uchar : t -> int -> Uchar.utf_decode

get_utf_8_uchar b i декодирует символ UTF-8 по индексу i в b.

val is_valid_utf_8 : t -> bool

is_valid_utf_8 b — true, если и только если b содержит корректные данные UTF-8.

UTF-16BE

val get_utf_16be_uchar : t -> int -> Uchar.utf_decode

get_utf_16be_uchar b i декодирует символ UTF-16BE по индексу i в b.

val is_valid_utf_16be : t -> bool

is_valid_utf_16be b — true, если и только если b содержит корректные данные UTF-16BE.

UTF-16LE

val get_utf_16le_uchar : t -> int -> Uchar.utf_decode

get_utf_16le_uchar b i декодирует символ UTF-16LE по индексу i в b.

val is_valid_utf_16le : t -> bool

is_valid_utf_16le b — true, если и только если b содержит корректные данные UTF-16LE.

Функции, отмеченные устаревшими

val create : int -> bytes
Устарело. Это устаревший псевдоним Bytes.create/BytesLabels.create.

create n возвращает новую последовательность байтов длиной n. Последовательность не инициализирована и содержит произвольные байты.

  • Raises Invalid_argument если n < 0 или n > Sys.max_string_length.
val set : bytes -> int -> char -> unit
Устарело. Это устаревший псевдоним Bytes.set/BytesLabels.set.

set s n c изменяет последовательность байтов s на месте, заменяя байт по индексу n на c. Также можно использовать s.[n] <- c вместо set s n c.

  • Raises Invalid_argument если n не является допустимым индексом в s.
val blit : string -> int -> bytes -> int -> int -> unit

blit src src_pos dst dst_pos len копирует len байтов из строки src, начиная с индекса src_pos, в последовательность байтов dst, начиная с символа номер dst_pos.

  • Raises Invalid_argument если src_pos и len не обозначают допустимый диапазон src, или если dst_pos и len не обозначают допустимый диапазон dst.
val copy : string -> string
Устарело. Поскольку строки неизменяемы, создавать идентичные копии не имеет большого смысла.

Возвращает копию данной строки.

val fill : bytes -> int -> int -> char -> unit
Устарело. Это устаревший псевдоним Bytes.fill/BytesLabels.fill.

fill s pos len c изменяет последовательность байтов s на месте, заменяя len байтов на c, начиная с pos.

  • Raises Invalid_argument если pos и len не обозначают допустимый подстроку s.
val uppercase : string -> string
Устаревшее. Функции, работающие с набором символов Latin-1, устарели.

Возвращает копию аргумента, в котором все строчные буквы переведены в заглавные, включая акцентированные буквы набора символов ISO Latin-1 (8859-1).

val lowercase : string -> string
Устаревшее. Функции, работающие с набором символов Latin-1, устарели.

Возвращает копию аргумента, в котором все заглавные буквы переведены в строчные, включая акцентированные буквы набора символов ISO Latin-1 (8859-1).

val capitalize : string -> string
Устаревшее. Функции, работающие с набором символов Latin-1, устарели.

Возвращает копию аргумента, с первой буквой, преобразованной в заглавную, используя набор символов ISO Latin-1 (8859-1).

val uncapitalize : string -> string
Устаревшее. Функции, работающие с набором символов Latin-1, устарели.

Возвращает копию аргумента, с первой буквой, преобразованной в строчную, используя набор символов ISO Latin-1 (8859-1).

Бинарное декодирование целых чисел

Функции в этом разделе бинарно декодируют целые числа из строк.

Все следующие функции вызывают Invalid_argument если символы, необходимые по индексу i для декодирования целого числа, недоступны.

Маленький порядок байтов (соответственно, большой порядок байтов) означает, что наименее (соответственно, наиболее) значимые байты хранятся первыми. Большой порядок байтов также известен как сетевой порядок байтов. Порядок байтов по умолчанию — это либо порядок байтов по возрастанию, либо по убыванию, в зависимости от Sys.big_endian.

32-битные и 64-битные целые числа представлены типами int32 и int64, которые могут быть интерпретированы как знакомые или беззнаковые числа.

8-битные и 16-битные целые числа представлены типом int, который имеет больше битов, чем бинарное кодирование. Эти дополнительные биты расширяются со знаком (или нулём) для функций, которые декодируют 8-битные или 16-битные целые числа и представляют их значениями int. 

val get_uint8 : string -> int -> int

get_uint8 b i является беззнаковым 8-битным целым числом b начиная с символа с индексом i.

  • Since 4.13.0
val get_int8 : string -> int -> int

get_int8 b i является знаковым 8-битным целым числом b начиная с символа с индексом i.

  • Since 4.13.0
val get_uint16_ne : string -> int -> int

get_uint16_ne b i является беззнаковым 16-битным целым числом b в порядке байтов по возрастанию, начиная с символа с индексом i.

  • Since 4.13.0
val get_uint16_be : string -> int -> int

get_uint16_be b i является беззнаковым 16-битным целым числом b в порядке байтов по убыванию, начиная с символа с индексом i.

  • Since 4.13.0
val get_uint16_le : string -> int -> int

get_uint16_le b i является беззнаковым 16-битным целым числом b в порядке байтов по возрастанию, начиная с символа с индексом i.

  • Since 4.13.0
val get_int16_ne : string -> int -> int

get_int16_ne b i является знаковым 16-битным целым числом b в порядке байтов по возрастанию, начиная с символа с индексом i.

  • Since 4.13.0
val get_int16_be : string -> int -> int

get_int16_be b i является знаковым 16-битным целым числом b в порядке байтов по убыванию, начиная с символа с индексом i.

  • Since 4.13.0
val get_int16_le : string -> int -> int

get_int16_le b i является знаковым 16-битным целым числом b в порядке байтов по возрастанию, начиная с символа с индексом i.

  • Since 4.13.0
val get_int32_ne : string -> int -> int32

get_int32_ne b i является 32-битным целым числом b в порядке байтов по возрастанию, начиная с символа с индексом i.

  • Since 4.13.0
val get_int32_be : string -> int -> int32

get_int32_be b i является 32-битным целым числом b в порядке байтов по убыванию, начиная с символа с индексом i.

  • Since 4.13.0
val get_int32_le : string -> int -> int32

get_int32_le b i является 32-битным целым числом b в порядке байтов по возрастанию, начиная с символа с индексом i.

  • Since 4.13.0
val get_int64_ne : string -> int -> int64

get_int64_ne b i является 64-битным целым числом b в порядке байтов по возрастанию, начиная с символа с индексом i.

  • Since 4.13.0
val get_int64_be : string -> int -> int64

get_int64_be b i является 64-битным целым числом b в порядке байтов по убыванию, начиная с символа с индексом i.

  • Since 4.13.0
val get_int64_le : string -> int -> int64

get_int64_le b i является 64-битным целым числом b в порядке байтов по возрастанию, начиная с символа с индексом i.

  • Since 4.13.0

© 1995-2022 INRIA.
https://v2.ocaml.org/releases/4.14/htmlman/libref/String.html

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API