strncasecmp — Сравнение первых n символов строк без учета регистра


strncasecmp

(PHP 4 >= 4.0.2, PHP 5, PHP 7)

strncasecmp — Бинарно-безопасное сравнение первых n символов строк без учета регистра

Описание

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

Список параметров

Количество символов, участвующих в сравнении.

Возвращаемые значения

Возвращает отрицательное число, если str1 меньше str2 , положительное число, если str1 больше str2 , и 0, если строки равны.

Смотрите также

  • strncmp() — Бинарно-безопасное сравнение первых n символов строк
  • preg_match() — Выполняет проверку на соответствие регулярному выражению
  • substr_compare() — Бинарно-безопасное сравнение 2 строк со смещением, с учетом или без учета регистра
  • strcasecmp() — Бинарно-безопасное сравнение строк без учета регистра
  • stristr() — Регистронезависимый вариант функции strstr
  • substr() — Возвращает подстроку

strncasecmp

strncasecmp — бинарно безопасное сравнение строк для первых n символов.

Описание

int strncasecmp (string str1, string str2, int len)

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

Возвращает 0, если str1 больше str2; 0, если они равны.

Сравнение строк, нечувствительных к регистру, в С++

Каков наилучший способ сделать нечувствительное к строкам сравнение строк в С++ без преобразования строки во все прописные или все строчные буквы?

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

Boost включает в себя удобный алгоритм для этого:

Воспользуйтесь стандартом char_traits . Напомним, что a std::string на самом деле является typedef для std::basic_string или более явно, std::basic_string > . Тип char_traits описывает, как сопоставляются символы, как они копируются, как они копируются и т.д. Все, что вам нужно сделать, это typedef новую строку поверх basic_string и предоставить ей свой собственный char_traits , который не учитывает регистр без учета регистра.

Детали находятся на Гуру недели № 29.

Проблема с повышением заключается в том, что вам нужно связать и зависеть от повышения. Нелегко в некоторых случаях (например, android).

И использование char_traits означает, что все ваши сравнения нечувствительны к регистру, что обычно не является тем, что вы хотите.

Этого должно хватить. Он должен быть достаточно эффективным. Не обрабатывает unicode или что-то еще.

Обновление: версия Bonus С++ 14 ( #include ):

Если вы находитесь в системе POSIX, вы можете использовать strcasecmp. Эта функция не является частью стандартного C, хотя и не доступна в Windows. Это приведет к нечувствительности к регистру по сравнению с 8-битными символами, если локаль является POSIX. Если локаль не POSIX, результаты undefined (так что это может сделать локализованное сравнение, или это может быть не так). Широкосимвольный эквивалент недоступен.

В противном случае большое количество исторических реализаций библиотеки C имеют функции stricmp() и strnicmp(). Visual С++ в Windows переименовал их все, префикс их с подчеркиванием, потому что они являются частью стандарта ANSI, поэтому в этой системе они называются _ stricmp или _strnicmp. Некоторые библиотеки могут также иметь широкосимвольные или многобайтовые эквивалентные функции (обычно называемые, например, wcsicmp, mbcsicmp и т.д.).

C и С++ в значительной степени не знают вопросов интернационализации, поэтому нет хорошего решения этой проблемы, за исключением использования сторонней библиотеки. Ознакомьтесь с IBM ICU (Международные компоненты для Unicode), если вам нужна надежная библиотека для C/С++. ICU предназначен как для систем Windows, так и для Unix.

Вы говорите о нечувствительном сравнении с немым регистром или с полным нормализованным Unicode-сравнением?

Немое сравнение не найдет строки, которые могут быть одинаковыми, но не бинарными.


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

Тем не менее, Unicode Normalization должно быть обязательно прочитано, особенно если вы планируете поддерживать Hangul, Thaï и другие азиатские языки.

Кроме того, IBM довольно запатентовала наиболее оптимизированные алгоритмы Unicode и сделала их общедоступными. Они также поддерживают реализацию: IBM ICU

strncasecmp()

Синтаксис:

strncasecmp(str1 , str2 , len )

Поддерживается следующими версиями PHP:

Описание функции:

Функция strncasecmp() сравнивает определенное количество символов в двух строках без учета регистра. Количество символов задается в аргументе len .

Возвращает три возможных значения:

число меньше 0 — если str1 меньше чем str2;

число больше 0 — если str1 больше чем str2.

0 — если str1 равно str2.

Обязательный аргумент. Первая сравниваемая строка.

Обязательный аргумент. Вторая сравниваемая строка.

string len Обязательный аргумент. Количество символов в каждой строке, которые будут использоваться для сравнения. int

Примеры:

Пример 1:

В этом примере первые 11 символов одинаковы, поэтому результат будет 0.

echo strncmp(‘Здравствуй Вова’, ‘Здравствуй Дима’, 11);
?>

Пример 2:

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

echo strncmp(‘Здравствуй Вова’, ‘здравствуй Дима’, 11);
?>

ООП / Функции для работы со строками и символами в Си

Функции для работы со строками и символами в Си

Илон Маск рекомендует:  Фиксированный дизайн. Позиционирование

определяет длину указанной строки, без учёта нуль-символа

выполняет побайтное копирование символов из строки s2 в строку s1

выполняет побайтное копирование n символов из строки s2 в строку s1. возвращает значения s1

объединяет строку s2 со строкой s1. Результат сохраняется в s1

объединяет n символов строки s2 со строкой s1. Результат сохраняется в s1

сравнивает строку s1 со строкой s2 и возвращает результат типа int: 0 –если строки эквивалентны, >0 – если s1 s2 С учётом регистра

сравнивает n символов строки s1 со строкой s2 и возвращает результат типа int: 0 –если строки эквивалентны, >0 – если s1 s2 С учётом регистра

сравнивает строку s1 со строкой s2 и возвращает результат типа int: 0 –если строки эквивалентны, >0 – если s1 s2 Без учёта регистра


сравнивает n символов строки s1 со строкой s2 и возвращает результат типа int: 0 –если строки эквивалентны, >0 – если s1 s2 Без учёта регистра

возвращает значение true, если с является буквой или цифрой, и false в других случаях

возвращает значение true, если с является буквой, и false в других случаях

возвращает значение true, если с является цифрой, и false в других случаях

возвращает значение true, если с является буквой нижнего регистра, и false в других случаях

возвращает значение true, если с является буквой верхнего регистра, и false в других случаях

возвращает значение true, если с является пробелом, и false в других случаях

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

поиск первого вхождения символа с в строке s. В случае удачного поиска возвращает указатель на место первого вхождения символа с. Если символ не найден, то возвращается ноль.

определяет длину начального сегмента строки s1, содержащего те символы, которые не входят в строку s2

возвращает длину начального сегмента строки s1, содержащего только те символы, которые входят в строку s2

Возвращает указатель первого вхождения любого символа строки s2 в строке s1

преобразует строку s1 в тип double

преобразует строку s1 в тип int

преобразует строку s1 в тип long int

Функции стандартной библиотеки ввода/вывода

считывает символ с со стандартного потока ввода, возвращает символ в формате int

считывает поток символов со стандартного устройства ввода в строку s до тех пор, пока не будет нажата клавиша ENTER

Функции для работы со строками — файлы string.h, stdlib.h

Прототип и краткое описание

double atof(char *str) ; Преобразует строку str в вещественное число типа double

int atoi(char *str) ; Преобразует строку str в десятичное целое число

long atol(char *str) ; Преобразует строку str в длинное десятичное целое число

char *itoa(int v, char *str, int baz) ; Преобразует целое v в строку str. При изображении числа используется основание baz (от 2 до 36). Для отрицательного числа и baz = 10 первый символ — минус(-)

char *ltoa(long v, char *str, int baz); Преобразует длинное целое v в строку str . При изображении числа используется основание baz (от 2 до 36)

char * strcat(char *sp, char *si); Приписывает строку si к строке sp (конкатенация строк)

char *strchr(char *str, int c) ; Ищет в строке str первое вхождение символа с

int strcmp(char *str1 , char *str2) ; Сравнивает строки str1 и str2 . Результат отрицателен, если strl меньше str2; равен нулю, если str1 равно str2 и положителен, если str1 больше str2 (сравнение беззнаковое)

char *strcpy(char *sp, char *si) ; Копирует байты строки si в строку sp

int strcspn(char *str1, char *str2) ; Определяет длину первого сегмента строки str1, содержащего символы, не входящие во множество символов строки str2

char *strdup(const char *str); Выделяет память и переносит в нее копию строки str

unsigned strlen(char *str); Вычисляет длину строки str

char *strlwr(char *str); Преобразует буквы верхнего регистра в строке в соответствующие буквы нижнего регистра


char *strncat(char *sp, char *si, int kol); Приписывает kol символов строки si к строке sp

int strncmp(char *str1, char *str2, int kol); Сравнивает части строк str1 и str2, причем рассматриваются первые kol символов. Результат отрицателен, если str1 меньше str2; равен нулю, если str1 равен str2, и положителен, если str1 больше str2

char *strncpy(char *sp, char *si, int kol); Колирует kol символов строки si в строку sp («хвост» отбрасывается или дополняется пробелами)

char *strnicmp(char *str1, char *str2, int kol); Сравнивает не более kol символов строки str1 и строки str2, не делая различия регистров

char *strnset(char *str, int с, int kol); Заменяет первые kol символов строки str символом с

char *strpbrk(char *str1, char *str2); Ищет в строке str1 первое появление любого из множества символов, входящих в строку str2

char *strrchr(char *str, int с); Ищет в строке str последнее вхождение символа с

int strset(char *str, int с); Заполняет строку str символом с

int strspn(char *str1, char *str2); Определяет длину первого сегмента строки str1, содержащего только символы, из множества символов строки str2

char *strstr(const char *str1, const char *str2); Ищет в строке str1 подстроки str2. Возвращает указатель на тот элемент в строке str1, с которого начинается подстрока str2

double *strtod(const char *str,char **endptr); Преобразует символьную строку str в число двойной точности. Если endpt нe равен null , то *endptr возвращает как указатель на символ, при достижении которого прекращено чтение строки str

char *strtok(char *str1, const char *str2); Ищет в строке str1 лексемы, выделенные символами из второй строки

Илон Маск рекомендует:  Что такое код setscrollrange

long *strtol(const char *str ,char **endptr,intbaz); Преобразует символьную строку str к значению «длинное число» с основанием baz(от 2 до 36). Если endptr не равен null, то *endptr возвращается как указатель на символ, при достижении которого прекращено чтение строки str

char *strupr(char *str) Преобразует буквы нижнего регистра в строке в соответствующие буквы верхнего регистра

char *ultoa(unsigned long v, char *str, int baz); Преобразует беззнаковое длинное целое v в строку str

void *calloc(unsigned n, unsigned m) ; Возвращает указатель на начало области динамически распределенной памяти для размещения n элементов по m байт каждый. При неудачном завершении возвращает значение null

unsigned coreleft(void); — для моделей памяти tiny, small, medium. unsigned long coreleft(void); — для других моделей памяти. Возвращает значение объема неиспользованной памяти, функция, уникальная для DOS, где приняты упомянутые модели памяти

void free (void *bl); Освобождает ранее выделенный блок динамически распределенной памяти с адресом первого байта bl

void *malloc(unsigned s); Возвращает указатель на блок 0 динамически распределенной памяти длиной s байт. При неудачном завершении возвращает значение null

void *realloc(void *bl, unsigned ns); Изменяет размер ранее выделенной динамической памяти с адресом bl до размера ns байт. Если bl равен null, то функция выполняется как malloc()

С++: сравнение строк с первым-символом без учета регистра

Мой вопрос похож на этот, но у меня две строки (как char * ), и задача заключается в замене функции strnicmp (доступно только для MS VC) с чем-то вроде boost::iequals .

Примечание strnicmp не stricmp — он сравнивает только первые n символов.

Есть ли какое-нибудь решение, более простое, чем это:

Если это действительно необходимо, напишите свою собственную функцию:

Для нечувствительности к регистру вам нужна пользовательская функция сравнения (или функтором):

Если я правильно понимаю, вы проверяете префикс. Самый простой способ сделать это:

(Обратите внимание на проверку размеров. s1 не может быть префиксом s2 , если он больше, чем s2 . И, конечно, std::equals будет встретить поведение undefined, если вызывается с s1 дольше, чем s2 .)

Для функции, определенной в терминах строк C (указатели символов), идущие «вверх» к строкам STL, кажется ужасно неэффективным, но, возможно, это совершенно преждевременное размышление с моей стороны.

Я бы рассмотрел прямое решение C «проще», но опять-таки это зависит от одной точки зрения.

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

Конечно, это предполагает, что строки ASCII, где tolower() имеют смысл.

Strncasecmp — Сравнение первых n символов строк без учета регистра


(PHP 4 >= 4.0.2, PHP 5)

strncasecmp — Сравнение первых n символов строк без учета регистра, безопасное для данных в двоичной форме

Описание int strncasecmp ( string str1, string str2, int len )

Возвращает отрицательное число, если str1 меньше, чем str2 ; положительное число, если str1 больше, чем str2 , и 0 если строки равны.

Пред. Начало След.
strnatcmp Уровень выше strncmp

Если Вы не нашли что искали, то рекомендую воспользоваться поиском по сайту:

Справочник по PHP : Функции работы с данными : Строковые функции : Функции сравнения

Материал из WebWikiABCD

Содержание

strcmp

Эта функция сравнивает две строки посимвольно (точнее, бобайтово) и возвращает:

  • 0 — если строки полностью совпадают;
  • -1 — если строка str1 лексикографически меньше str2;
  • 1 — если, наоборот, str1 «больше» str2.

Так как сравнение идет побайтово, то регистр символов влияет на результаты сравнений.

strncmp

Сравнивает начала строк.

Эта функция отличается от strcmp() тем, что сравнивает не все слово целиком, а первые len байтов. В случае, если len меньше длины наименьшей из строк, то строки сравниваются целиком.

Эта функция сравнивает две строки посимвольно (точнее, побайтово) и возвращает:

  • 0 — если строки полностью совпадают;
  • -1 — если строка str1 лексикографически меньше str2;
  • 1 — если, наоборот, str1 «больше» str2.

Так как сравнение идет побайтово, то регистр символов влияет на результаты сравнений.

strcasecmp

Сравнивает строки без учета регистра.

То же самое, что и strcmp(), только при работе не учитывается регистр букв.

strncasecmp

Сравнивает начала строк без учета регистра.

Функция strncasecmp() является комбинацией функций strcasecmp() и strncmp().

strnatcmp

Производит «естественное» сравнение строк.

Данная функция имитирует сравнение строк, которое использовал бы человек.

Данный скприпт выведет следующее:

strnatcasecmp

Производит «естественное» сравнение строк без учета регистра.


То же, что и strnatcmp(), только игнорирует регистр.

similar_text

Производит определение схожести двух строк.

Функция similar_text() вычисляет схожесть двух строк по алгоритму, описанному Оливером (Oliver [1993]). Но вместо стека (как в псевдокоде Оливера) она использует рекурсивные вызовы.

Сложность алгоритма делает функцию медленной, и ее скорость пропорциональна (N^3), где N — длина наибольшей строки.

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

levenshtein

Определение различия Левенштейна двух строк.

«Различие Левенштейна» — это минимальное чило символов, которое требовалось бы заменить, вставить или удалить для того, чтобы превратить строку str1 в str2. Сложность алгоритма пропорциональна произведению длин строк str1 и str2, что делает функцию более быстродействующей, чем similar_text().

Первая форма функции возвращает число необходимых операций над символами строк для трансформации str1 в str2.

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

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

Функция cost вызывается со следующими аргументами:

  • применяемая операция (вставить, изменить, удалить): «I*quot;, «R», «D»;
  • фактический символ первой строки
  • фактический символ второй строки
  • позиция строки 1
  • позиция строки 2
  • оставшаяся длина строки 1
  • оставшаяся длина строки 2
Илон Маск рекомендует:  Iis о шифровании

Вызываемая функция должна будет возвратить стоимость этой операции.

Если длина одной из строк более 255 символов, функция levenshtein() возвращает -1, но такая длина более чем достаточна.

УЧЕБНИК PHP

Функции сравнения строк

Эта функция сравнения строк. Она сравнивает две строки и возвращает:

  • 0 — если строки полностью совпадают;
  • 1 — если, строка str1 лексикографически больше str2;
  • 1 – если, наоборот, строка str1 лексикографически меньше str2

Функция является чувствительной к регистру, т.е. регистр символов влияет на результаты сравнений (поскольку сравнение происходит побайтово).

Result of strcmp (ttt , tttttttttt) is -1
Result of strcmp (tttttttttt, ttt) is 1
Result of strcmp (ttt, ttt) is 0

strncmp()

Эта функция отличается от strcmp() тем, что сравнивает начала строк, а точнее первые len байтов. Если len меньше длины наименьшей из строк, то строки сравниваются целиком.

В остальном функция ведет себя аналогично strcmp(), т.е. возвращает:

  • 0 — если строки полностью совпадают;
  • 1 — если, строка str1 лексикографически больше str2;
  • 1 – если, наоборот, строка str1 лексикографически меньше str2

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

strcasecmp()

Функция работает аналогично strcmp(), только при работе не учитывается регистр букв.

strncasecmp()


Функция strncasecmp() cравнивает начала строк без учета регистра.

strnatcmp()

Производит так называемое «естественное» сравнение строк.

Об этой функции поговорим поподробнее. Данная функция является имитатором сравнение строк человеком, т.е. она сравнивает строки так, как их сравнивал бы человек. Т.е., если, к примеру, мы будем сравнивать файлы с названиями pict1.gif, pict20.gif, pict2.gif, pict10.gif, то обычное сравнение приведет к следующему их расположению: pict1.gif, pict10.gif, pict2.gif, pict20.gif. Естественная же сортировка даст результат, который нам более привычен: pict1.gif, pict2.gif, pict10.gif, pict20.gif.

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

Этот скрипт выведет следующее:

обычная сортировка:
Array([0]=>pict1.gif [1]=> pict10.gif [2]=>pict2.gif [3]pict20.gif)
естественная сортировка:
Array([0]=>pict1.gif [1]=> pict2.gif [2]=>pict10.gif [3]pict20.gif)

strnatcasecmp()

Производит «естественное» сравнение строк без учета регистра. Функция выполняет то же самое, что и strnatcmp(), только без учета регистра.

similar_text()

Эта функция производит определение схожести двух строк.

Функция similar_text() определяет схожесть двух строк по алгоритму Оливера. Функция возвращает число символов, совпавших в строках str_first и str_second. Третий необязательный параметр передается по ссылке и в нем сохраняется процент совпадения строк.

Вместо стека, как в алгоритме Оливера, эта функция использует рекурсивные вызовы. Сложность алгоритма этой функции равна O((max(n,m))3), что делает эту функцию медленной. (Грубо говоря, скорость выполнения этой функции пропорциональна N3, где N – длина наибольшей строки.

Результат выполнения функции similar_text() для строк Hello, world! и Hello! в количестве символов:
6
и в процентах:
63.157894736842

levenshtein()

Функция выполняет определение различия Левенштейна двух строк.

Под понятием «различие Левенштейна» понимается минимальное число символов, которое требовалось бы заменить, вставить или удалить для того, чтобы превратить строку str1 в str2.

Сложность алгоритма этой функции равна O(m*n), т.е. пропорциональна произведению длин строк str1 и str2, поэтому эта функция намного более быстрая, чем функция similar_text().

Как видим, у функции три вида синтаксиса. В первом случае функция возвращает число необходимых операций над символами строк для преобразования str1 в str2:

Во втором случае добавляется три дополнительных параметра: стоимость операции вставки cost_ins, замены cost_rep и удаления cost_del. Естественно, функция в этом случае становится менее быстродействующей. Возвращается интегральный показатель сложности трансформации (ИПСТ).

Число 21, между прочим, это 7*3 :). Т.е. ИПСТ равен произведению количества символов, необходимых для замены (а как мы посчитали в предыдущем примере их надобно 7) на стоимость, в этом случае, одной из операций. В этом примере, поскольку стоимость одинакова, не имеет значения, какую операцию брать. В случае, если стоимости различны, при вычисления ИПСТ берется наибольший. Т.е., если мы напишем в этом примере

то функция вернет нам значение 42.

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

Сравнение последних символов без учета регистра (с предикатом?)

у меня есть std::wstring fName имя файла, для которого я хотел бы проверить если он имеет расширение .txt. Это работает:

но он чувствителен к регистру, чего я не хочу: мне нужно blah.tXt а также hello.TXT быть принятым

Это должно работать как версия без учета регистра:

но std::search вероятно, далеко от оптимального, потому что он ищет, если это содержит шаблон (где-нибудь в исходной строке), и здесь мне нужно только сравнить символ за символом.

Поскольку мне нужно проверить это для миллионов имен файлов, Как я могу улучшить производительность, чтобы проверить, если имя файла имеет расширение (без учета регистра) .txt ?

Я не хочу простого решения:

давайте строчные fName в новой переменной (или даже в нижнем регистре только 4 последних символа fName )

потому что это потребует новых переменных, памяти и т. д. Могу ли я сравнить на месте, с пользовательским предикатом [](wchar_t ch1, wchar_t ch2) < return tolower(ch1) == ch2; >) ?

Примечание: я не ищу ни Boost-решений, ни подобных решений Сравнение строк без учета регистра в C ++ или много подобных вопросов, которые не оптимизированы для производительности.

Понравилась статья? Поделиться с друзьями:
Кодинг, CSS и SQL