---

4.5 Сравнение символов и строк

Функция: char-equal character1 character2 ¶

Эта функция возвращает t, если аргументы представляют один и тот же символ, и nil в противном случае. Эта функция игнорирует различия в регистре, если case-fold-search не равен nil.

(char-equal ?x ?x)
     ⇒ t
(let ((case-fold-search nil))
  (char-equal ?x ?X))
     ⇒ nil

Функция: string-equal string1 string2 ¶

Эта функция возвращает t, если символы двух строк совпадают в точности. Также допускаются символы в качестве аргументов, в случае чего используются имена символов. Регистр всегда имеет значение, независимо от case-fold-search.

Эта функция эквивалентна equal для сравнения двух строк (см. Предикаты равенства). В частности, игнорируются текстовые свойства двух строк; используйте equal-including-properties, если вам необходимо различать строки, которые различаются только своими текстовыми свойствами. Однако, в отличие от equal, если хотя бы один аргумент не является строкой или символом, string-equal выдает ошибку.

(string-equal "abc" "abc")
     ⇒ t
(string-equal "abc" "ABC")
     ⇒ nil
(string-equal "ab" "ABC")
     ⇒ nil

Однобайтовая и многобайтовая строка равны в смысле string-equal, тогда и только тогда, когда они содержат одинаковую последовательность кодов символов, все из которых находятся в диапазоне 0–127 (ASCII). См. Представления текста.

Функция: string= string1 string2 ¶

string= — это другое имя для string-equal.

Функция: string-equal-ignore-case string1 string2 ¶

string-equal-ignore-case сравнивает строки, игнорируя различия в регистре, подобно char-equal, когда case-fold-search равен t.

Функция: string-collate-equalp string1 string2 &optional locale ignore-case ¶

Эта функция возвращает t, если string1 и string2 равны с точки зрения правил сопоставления указанного locale, который по умолчанию соответствует локали вашей текущей системы. Правило сопоставления определяется не только лексическим порядком символов, содержащихся в string1 и string2, но и дополнительными правилами отношений между этими символами. Обычно оно определяется средой локали, в которой работает Emacs, и стандартной библиотекой C, с которой был скомпонован Emacs⁴.

Например, символы с разными кодовыми точками, но одинаковым смыслом, такие как разные символы с гравис-акцентом Unicode, могут в некоторых локалиях считаться равными:

(string-collate-equalp (string ?\uFF40) (string ?\u1FEF))
     ⇒ t

Необязательный аргумент locale, строка, переопределяет установку идентификатора вашей текущей локали для сопоставления. Значение зависит от системы; locale "en_US.UTF-8" применимо в системах POSIX, в то время как в системах MS-Windows это может быть, например, "enu_USA.1252".

Если ignore-case не равен nil, символы сравниваются без учета регистра путем преобразования их в нижний регистр. Однако, если базовая системная библиотека не предоставляет правила сопоставления, специфичные для локали, эта функция возвращается к string-equal, в случае чего аргумент ignore-case игнорируется, и сравнение всегда будет чувствительным к регистру.

Чтобы эмулировать сопоставление, соответствующее Unicode, в системах MS-Windows, привяжите w32-collate-ignore-punctuation к значению, не равному nil, поскольку часть кодировки локали в MS-Windows не может быть "UTF-8".

Если ваша система не поддерживает среду локали, эта функция ведет себя как string-equal.

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

Функция: string-lessp string1 string2 ¶

Эта функция сравнивает две строки символ за символом. Она одновременно сканирует обе строки, чтобы найти первую пару соответствующих символов, которые не совпадают. Если меньший из этих двух символов является символом из string1, то string1 меньше, и эта функция возвращает t. Если меньший символ — из string2, то string1 больше, и эта функция возвращает nil. Если две строки полностью совпадают, значение равно nil.

Пары символов сравниваются в соответствии с их кодами символов. Имейте в виду, что строчные буквы имеют более высокие числовые значения в наборе символов ASCII, чем их заглавные аналоги; цифры и многие знаки препинации имеют более низкое числовое значение, чем заглавные буквы. Символ ASCII меньше любого не-ASCII символа; однобайтовый не-ASCII символ всегда меньше любого многобайтового не-ASCII символа (см. Представления текста).

(string-lessp "abc" "abd")
     ⇒ t
(string-lessp "abd" "abc")
     ⇒ nil
(string-lessp "123" "abc")
     ⇒ t

Когда строки имеют разную длину, и они совпадают до длины string1, то результат равен t. Если они совпадают до длины string2, результат равен nil. Строка без символов меньше любой другой строки.

(string-lessp "" "abc")
     ⇒ t
(string-lessp "ab" "abc")
     ⇒ t
(string-lessp "abc" "")
     ⇒ nil
(string-lessp "abc" "ab")
     ⇒ nil
(string-lessp "" "")
     ⇒ nil

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

Функция: string< string1 string2 ¶

string< — это другое имя для string-lessp.

Функция: string-greaterp string1 string2 ¶

Эта функция возвращает результат сравнения string1 и string2 в обратном порядке, то есть эквивалентно вызову (string-lessp string2 string1).

Функция: string> string1 string2 ¶

string> — это другое имя для string-greaterp.

Функция: string-collate-lessp string1 string2 &optional locale ignore-case ¶

Эта функция возвращает t, если string1 меньше string2 в порядке сопоставления указанной locale, который по умолчанию соответствует локали вашей текущей системы. Порядок сопоставления определяется не только лексическим порядком символов, содержащихся в string1 и string2, но и дополнительными правилами отношений между этими символами. Обычно он определяется средой локали, в которой работает Emacs, и стандартной библиотекой C, с которой был скомпонован Emacs.

Например, знаки препинания и пробельные символы могут игнорироваться при сортировке (см. Последовательности):

(sort '("11" "12" "1 1" "1 2" "1.1" "1.2")
       :lessp #'string-collate-lessp)
     ⇒ ("11" "1 1" "1.1" "12" "1 2" "1.2")

Это поведение зависит от системы; например, знаки препинания и пробелы никогда не игнорируются в Cygwin, независимо от локали.

Необязательный аргумент locale, строка, переопределяет установку идентификатора вашей текущей локали для сопоставления. Значение зависит от системы; locale "en_US.UTF-8" применимо в системах POSIX, в то время как в системах MS-Windows это может быть, например, "enu_USA.1252". Значение locale "POSIX" или "C" заставляет string-collate-lessp вести себя как string-lessp:

(sort '("11" "12" "1 1" "1 2" "1.1" "1.2")
      :lessp (lambda (s1 s2) (string-collate-lessp s1 s2 "POSIX")))
     ⇒ ("1 1" "1 2" "1.1" "1.2" "11" "12")

Если ignore-case не равен nil, символы сравниваются без учета регистра путем преобразования их в нижний регистр. Однако, если базовая системная библиотека не предоставляет правила сопоставления, специфичные для локали, эта функция возвращается к string-lessp, в случае чего аргумент ignore-case игнорируется, и сравнение всегда будет чувствительным к регистру.

Чтобы эмулировать сопоставление, соответствующее Unicode, в системах MS-Windows, привяжите w32-collate-ignore-punctuation к значению, не равному nil, поскольку часть кодировки локали в MS-Windows не может быть "UTF-8".

Если ваша система не поддерживает среду локали, эта функция ведет себя как string-lessp.

Функция: string-version-lessp string1 string2 ¶

Эта функция сравнивает строки лексикографически, за исключением того, что она обрабатывает последовательности числовых символов как десятичное число, а затем сравнивает эти числа. Таким образом, ‘foo2.png’ считается “меньше” чем ‘foo12.png’ в соответствии с этим предикатом, даже если ‘12’ лексикографически “меньше” чем ‘2’.

Функция: string-prefix-p string1 string2 &optional ignore-case ¶

Эта функция возвращает не-nil, если string1 является префиксом string2; то есть, если string2 начинается с string1. Если необязательный аргумент ignore-case не равен nil, сравнение игнорирует различия в регистре.

Функция: string-suffix-p suffix string &optional ignore-case ¶

Эта функция возвращает не-nil, если suffix является суффиксом string; то есть, если string заканчивается на suffix. Если необязательный аргумент ignore-case не равен nil, сравнение игнорирует различия в регистре.

Функция: string-search needle haystack &optional start-pos ¶

Возвращает позицию первого вхождения needle в haystack, причем оба являются строками. Если start-pos не равен nil, начинать поиск с этой позиции в haystack. Возвращает nil, если совпадение не найдено. Эта функция учитывает только символы в строках при сравнении; текстовые свойства игнорируются. Совпадение всегда чувствительно к регистру.

Функция: compare-strings string1 start1 end1 string2 start2 end2 &optional ignore-case ¶

Эта функция сравнивает указанную часть string1 с указанной частью string2. Указанная часть string1 начинается с индекса start1 (включительно) до индекса end1 (исключительно); nil для start1 означает начало строки, а nil для end1 означает длину строки. Точно так же, указанная часть string2 начинается с индекса start2 до индекса end2.

Строки сравниваются по числовым значениям их символов. Например, str1 считается меньше, чем str2, если ее первый различающийся символ имеет меньшее числовое значение. Если ignore-case не равен nil, символы преобразуются в верхний регистр, используя таблицу регистра текущего буфера (см. Таблица регистра), перед сравнением. Однобайтовые строки преобразуются в многобайтовые для сравнения (см. Представления текста), так что однобайтовая строка и ее преобразование в многобайтовую всегда считаются равными.

Если указанные части двух строк совпадают, значение равно t. В противном случае значение — это целое число, которое указывает, сколько ведущих символов совпадают, и какая строка меньше. Его абсолютное значение равно одному плюс количество совпадающих символов в начале двух строк. Знак отрицательный, если string1 (или ее указанная часть) меньше.

Функция: string-distance string1 string2 &optional bytecompare ¶

Эта функция возвращает расстояние Левенштейна между исходной строкой string1 и целевой строкой string2. Расстояние Левенштейна — это количество односимвольных изменений — удалений, вставок или замен — необходимых для преобразования исходной строки в целевую; это возможное определение расстояния редактирования между строками.

Регистр букв строк важен для вычисленного расстояния, но их текстовые свойства игнорируются. Если необязательный аргумент bytecompare не равен nil, функция вычисляет расстояние в терминах байтов, а не символов. Байтовое сравнение использует внутреннее представление Emacs символов, поэтому оно может давать неточные результаты для многобайтовых строк, содержащих необработанные байты (см. Представления текста); сделайте строки однобайтовыми, закодировав их (см. Явное кодирование и декодирование), если вам нужны точные результаты с необработанными байтами.

Функция: assoc-string key alist &optional case-fold ¶

Эта функция работает как assoc, за исключением того, что key должен быть строкой или символом, а сравнение выполняется с использованием compare-strings. Символы преобразуются в строки перед проверкой. Если case-fold не равен nil, key и элементы alist преобразуются в верхний регистр перед сравнением. В отличие от assoc, эта функция также может сопоставлять элементы alist, которые являются строками или символами, а не консами. В частности, alist может быть списком строк или символов, а не фактическим alist. См. Списки ассоциаций.

См. также функцию compare-buffer-substrings в Сравнение текста для способа сравнения текста в буферах. Функция string-match, которая сопоставляет регулярное выражение со строкой, может использоваться для некоторого вида сравнения строк; см. Поиск по регулярным выражениям.