Как осуществляется сравнение строк при помощи оператора

Comparison Operators in Visual Basic

Операторы сравнения сравнивают два выражения и возвращают Boolean значение, представляющее связь их значений. Существуют операторы для сравнения числовых значений, операторы для сравнения строк и операторы для сравнения объектов. Здесь рассматриваются все три типа операторов.

Сравнение числовых значений

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

Оператор	Условие протестировано	Примеры
= (Равенство)	Равно ли значение первого выражения значению второго?	23 = 33 ‘ False

Сравнение строк

Visual Basic сравнивает строки с помощью оператора Like , а также числовых операторов сравнения. Оператор Like позволяет указать шаблон. Затем строка сравнивается с шаблоном, и если она совпадает, результатом будет True . В противном случае результат будет False . Числовые операторы позволяют сравнивать String значения на основе их порядка сортировки, как показано в следующем примере.

‘ The result of the preceding comparison is True.

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

‘ The result of the preceding comparison is True.

Если одна строка является префиксом другой, например «aa» и «aaa», то длинная строка считается больше, чем более короткая строка. Это показано в следующем примере.

‘ The result of the preceding comparison is True.

Порядок сортировки основан на двоичном или текстовом сравнении в зависимости от параметра Option Compare . Дополнительные сведения см. в разделе Оператор Option Compare.

Сравнение объектов

Visual Basic сравнивает две ссылочные переменные объекта с оператором Is и Оператором IsNot. Можно использовать любой из этих операторов, чтобы определить, ссылаются ли две ссылочные переменные на один и тот же экземпляр объекта. Это показано в следующем примере.

Dim x As testClass Dim y As New testClass() x = y If x Is y Then ' Insert code to run if x and y point to the same instance. End If 

В предыдущем примере x Is y вычисляется как True , так как обе переменные ссылаются на один и тот же экземпляр. Сравните этот результат со следующим примером.

Dim x As New customer() Dim y As New customer() If x Is y Then ' Insert code to run if x and y point to the same instance. End If 

В предыдущем примере x Is y вычисляется False как , так как переменные ссылаются на объекты одного типа, они ссылаются на разные экземпляры этого типа.

Если требуется проверить наличие двух объектов, не указывающих на один и тот же экземпляр, IsNot оператор позволяет избежать грамматического неуклюжего Not сочетания и Is . Это показано в следующем примере.

Dim a As New classA() Dim b As New classB() If a IsNot b Then ' Insert code to run if a and b point to different instances. End If 

В предыдущем примере If a IsNot b эквивалентно If Not a Is b .

Сравнение типа объекта

Вы можете проверить, имеет ли объект определенный тип, с помощью TypeOf выражения . Is . Синтаксис выглядит следующим образом:

Если typename задает тип интерфейса, выражение TypeOf . Is возвращает значение True , если объект реализует тип интерфейса. Если typename является типом класса, выражение возвращает True значение , если объект является экземпляром указанного класса или класса, производного от указанного класса. Это показано в следующем примере.

Dim x As System.Windows.Forms.Button x = New System.Windows.Forms.Button() If TypeOf x Is System.Windows.Forms.Control Then ' Insert code to run if x is of type System.Windows.Forms.Control. End If 

В предыдущем примере выражение принимает значение , TypeOf x Is Control так как тип имеет тип x Button , который наследуется от Control . True

Дополнительные сведения см. в разделе Оператор TypeOf.

См. также раздел

• Сравнения значений
• Операторы сравнения
• Операторы
• Арифметические операторы в Visual Basic
• Операторы объединения в Visual Basic
• Логические и побитовые операторы в Visual Basic

Совместная работа с нами на GitHub

Источник этого содержимого можно найти на GitHub, где также можно создавать и просматривать проблемы и запросы на вытягивание. Дополнительные сведения см. в нашем руководстве для участников.

Как сравнить строки в Python? Операторы сравнения строк

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

Основные операторы сравнения в Python

Итак, в языке программирования Python для сравнения строк используют следующие операторы:

• оператор < , «меньше»;
• оператор
• оператор == , «равно»;
• оператор != , «не равно»;
• оператор > , «больше»;
• оператор >= , «больше или равно».

Использование оператора «больше/меньше»

Ниже вы увидите простейший пример сравнения строк в Python с помощью соответствующих операторов: > и < . Давайте сравним строки со словами banana и apple:

 
print("apple" > "banana") False print("apple" < "banana") True
Так как буква «a» находится перед «b», слово apple будет находиться перед словом banana, что логично (то есть banana больше, чем apple). Однако всё сложнее, чем может показаться на первый взгляд. Давайте для наглядности сравним, равны ли слова Apple и apple:
 
print("apple" == "Apple") False print("apple" > "Apple") True
Мы увидим отсутствие равенства, а всё потому, что в Python одинаковые буквы, имеющие разный регистр, считаются разными символами, и компьютер их различает по присвоенным им уникальным значениям.
Что касается нашей ситуации, то здесь латинская «А» имеет значение 65, в то время как значение строчной «а» равно 97.
Кстати, если хотите узнать уникальное значение какого-нибудь символа, используйте функцию ord:
 
print(ord("A")) 65
При сравнении символов или строк, Python конвертирует символы в их соответствующие порядковые значения, после чего сравнивает слева направо.
Существует функция chr, преобразовывающая порядковое значение в символ. Пример:
 
print(chr(1040)) А
Например, кириллическая А соответствует значению 1040. Есть свои значения у цифр, а также вспомогательных знаков, включая «?», «=», пробел.
В принципе, вы всегда можете выполнить сравнение строк в Python, предварительно конвертировав строки в один формат, к примеру, в нижний регистр (используем метод lower ):
 
str1 = "apple" str2 = "Apple" str2.lower() print(str1 == str1) True
Применение оператора «равенство»
Мы можем проверить, равны ли строки, посредством оператора == :
 
print("строка1" == "строка2") False
Естественно, строки не являются равными, т. к. выполняется точное сравнение в Python. Неравными будут и те строки, которые содержат одинаковые, но переставленные местами символы. В последнем случае есть выход: превратить нашу строку в список, отсортировать, сравнить и вывести содержимое:
 
strA = "abcde" strB = "abdec" print(sorted(list(strA)) == sorted(list(strB))) print(sorted(list(strA))) print(sorted(list(strB))) True ['a', 'b', 'c', 'd', 'e'] ['a', 'b', 'c', 'd', 'e']
Использование оператора «не равно»
Оператор != выполняет проверку неравенства:
 
print("abc" != "zxc") True
Разумеется, результат True, ведь abc не равно zxc.
Применение операторов «больше или равно/меньше или равно»
 
print("abc" 
В нашем случае «abc» меньше.
Аналогично работает и оператор >= :
 
print("abc" >= "abc") True
В этой ситуации очевидно, что строки равны.
Программирование в "Эврике"
Раньше мы имели дело с числовыми данными (целыми и действительными), а также со списками чисел. Другим часто используемым типом данных являются строки. В строковых данных можно хранить фамилии и имена, адреса, названия товаров и т.д. Чтобы задать в программе строку необходимо заключить последовательность символов в двойные кавычки:
a="У лукоморья дуб зеленый" b="" # Это пустая строка
Считать строковую переменную с клавиатуры можно при помощи стандартной функции input , при этом пользователь также должен заключить вводимую строку в кавычки. Пример:
a=input()
Конкатенация строк
Главная операция со строками — их объединение, когда одна строка записывается после другой строки. Эта операция называется и для нее используется оператор + :
a="abc" b="xyz" c=a+b print c # Будет напечатано abcxyz
Также при помощи оператора * можно многократно повторять одну и ту же строку. "Умножать" строку можно только на натуральное число:
print "="*20 # Будет напечатано 20 знаков " section">Выбор подстроки 
Со строками можно работать во многом как и со списками, рассматривая строку, как список отдельных символов. Функция len для строки возвращает ее длину. Все символы строки пронумерованы начиная с 0, а также в обратном порядке (с конца) начиная с -1. Например, если s="abc", то len(s) возвращает значение 3, s[0] и s[-3] — это символ "a", s[1] и s[-2] — это "b", s[2] и s[-1]— это символ "c". Обращение к несуществующему элементу строки приведет к ошибке IndexError: string index out of range.
 
Символ строки: a b c Его индекс: 0 1 2 или такой: -3 -2 -1
Помимо обращения к отдельным символам строки, из строки можно выбрать подстроку в виде s[x:y] , где s — идентификатор строки, x — номер первого символа подстроки, y — номер первого символа, который не будет включен в подстроку. Пример:
s="abcdefgh" print s[2:6] # Будет напечатано cdef
В этом примере из строки s выбирается подстрока s[2:6] , состоящая из символов с индексами от 2 до 5.
При выборе подстроки можно не указать номер начального символа, тогда считается, что он равен 0 (то есть подстрока начинается с начала строки) или последний символ (тогда он считается равным длине строки, то есть подстрока заканчивается концом исходной строки). Также можно использовать отрицательные числа для задания номеров символов. Таким образом, извлечь из строки s первые три символа можно так: s[:3] , а последние три символа: s[-3:] . Указание недопустимых для данной строки индексов при выборе подстроки допускается и не приводит к ошибке.
В отличии от списков, изменять отдельные элементы элементы (то есть символы в строке) нельзя. Вместо этого можно пользоваться конкатенацией строк. Например, если хочется в строке s заменить первый символ на букву "a" , то это можно сделать при помощи конкатенации строки "a" и всей строки s за исключением первого символа: s="a"+s[1:] .
Рассмотрим пример программы, которая считывает строку с клавиатуры и находит в ней первое слово (то есть все символы до первого пробела.
s=input() # 1 for i in range(len(s)): # 2 if s[i]==" ": # 3 print s[:i] # 4 break # 5
В первой строке программы в переменную s считывается строка с клавиатуры. Затем организовывается цикл, в котором переменная s меняется от 0 до len(s)-1 , то есть переменная i принимает подряд все номера символов в строке. В третьей строке программы проверяется, является ли i -й символ строки пробелом (то есть совпадает ли он со строкой из одного пробела). Если проверяемое условие истинно, то был найден первый слева строки пробел, на экран печатается первые i символов строки, то есть все символы с начала строки до найденного пробела, после чего выполнение цикла завершается инструкцией break .
Сравнение строк
Строки можно сравнивать между собой на равенство или неравенство при помощи операторов сравнения == и != . Также можно сравнивать строки при помощи операторов < , , >= , при этом строки сравниваются в лексикографическом (то есть алфавитном) порядке. Например, верны будут следующие неравенства: "a"
Приведем пример программы, которая по данной строке выбрасывает из нее все заглавные буквы латинского алфавита:
s=input() # 1 t="" # 2 for i in range(len(s)): # 3 if s[i]>="A" and s[i]
В первой строке программы мы считывает строку s , затем заводим пустую строку t , в которую будем по очереди копировать все символы строки s при условии, что они не являются заглавными буквами. Далее в строке 3 организовывается цикл, в котором переменная i принимает всевозможные значения индексов элементов строки s , то есть от 0 до len(s)-1 . Внутри цикла мы проверяем, является ли символ s[i] заглавной буквой, сравнив его со строками "A" и "Z" (строка 4 программы). В случае истинности проверяемого условия пропускаем этот символ (строка 5 программы), иначе выполняется строка 6 , в которой в конец строки t дописывается символ s[i] . Завершается программа выводом строки t на экран.

Строки
С точки зрения регулярного программирования строковый тип данных string относится к числу самых важных в C#. Этот тип определяет и поддерживает символьные строки. В целом ряде других языков программирования строка представляет собой массив символов. А в C# строки являются объектами. Следовательно, тип string относится к числу ссылочных.
Построение строк
Самый простой способ построить символьную строку — воспользоваться строковым литералом. Например, в следующей строке кода переменной ссылки на строку str присваивается ссылка на строковый литерал:
string str = "Пример строки";
В данном случае переменная str инициализируется последовательностью символов "Пример строки". Объект типа string можно также создать из массива типа char. Например:
char[] chararray = ; string str = new string(chararray);
Как только объект типа string будет создан, его можно использовать везде, где только требуется строка текста, заключенного в кавычки.
Постоянство строк
Как ни странно, содержимое объекта типа string не подлежит изменению. Это означает, что однажды созданную последовательность символов изменить нельзя. Но данное ограничение способствует более эффективной реализации символьных строк. Поэтому этот, на первый взгляд, очевидный недостаток на самом деле превращается в преимущество. Так, если требуется строка в качестве разновидности уже имеющейся строки, то для этой цели следует создать новую строку, содержащую все необходимые изменения. А поскольку неиспользуемые строковые объекты автоматически собираются в "мусор", то о дальнейшей судьбе ненужных строк можно даже не беспокоиться.
Следует, однако, подчеркнуть, что переменные ссылки на строки (т.е. объекты типа string) подлежат изменению, а следовательно, они могут ссылаться на другой объект. Но содержимое самого объекта типа string не меняется после его создания.
static void addNewString()
Скомпилируем приложение и загрузим результирующую сборку в утилиту ildasm.exe. На рисунке показан CIL-код, который будет сгенерирован для метода void addNewString():

Обратите внимание на наличие многочисленных вызовов кода операции ldstr (загрузка строки). Этот код операции ldstr в CIL предусматривает выполнение загрузки нового объекта string в управляемую кучу. В результате предыдущий объект, в котором содержалось значение "This is my stroke", будет в конечном итоге удален сборщиком мусора.
Работа со строками
В классе System.String предоставляется набор методов для определения длины символьных данных, поиска подстроки в текущей строке, преобразования символов из верхнего регистра в нижний и наоборот, и т.д. Далее мы рассмотрим этот класс более подробно.
Поле, индексатор и свойство класса String
В классе String определено единственное поле:
public static readonly string Empty;
Поле Empty обозначает пустую строку, т.е. такую строку, которая не содержит символы. Этим оно отличается от пустой ссылки типа String, которая просто делается на несуществующий объект.
Помимо этого, в классе String определен единственный индексатор, доступный только для чтения:
public char this[int index]
Этот индексатор позволяет получить символ по указанному индексу. Индексация строк, как и массивов, начинается с нуля. Объекты типа String отличаются постоянством и не изменяются, поэтому вполне логично, что в классе String поддерживается индексатор, доступный только для чтения.
И наконец, в классе String определено единственное свойство, доступное только для чтения:
public int Length
Свойство Length возвращает количество символов в строке. В примере ниже показано использование индексатора и свойства Length:
using System; class Example < static void Main() < string str = "Простая строка"; // Получить длину строки и 6й символ в строке используя индексатор Console.WriteLine("Длина строки - , 6й символ - ''", str.Length, str[5]); > >
Операторы класса String
В классе String перегружаются два следующих оператора: == и !=. Оператор == служит для проверки двух символьных строк на равенство. Когда оператор == применяется к ссылкам на объекты, он обычно проверяет, делаются ли обе ссылки на один и тот же объект. А когда оператор == применяется к ссылкам на объекты типа String, то на предмет равенства сравнивается содержимое самих строк. Это же относится и к оператору !=. Когда он применяется к ссылкам на объекты типа String, то на предмет неравенства сравнивается содержимое самих строк. В то же время другие операторы отношения, в том числе =, сравнивают ссылки на объекты типа String таким же образом, как и на объекты других типов. А для того чтобы проверить, является ли одна строка больше другой, следует вызвать метод Compare(), определенный в классе String.
Как станет ясно дальше, во многих видах сравнения символьных строк используются сведения о культурной среде. Но это не относится к операторам == и !=. Ведь они просто сравнивают порядковые значения символов в строках. (Иными словами, они сравнивают двоичные значения символов, не видоизмененные нормами культурной среды, т.е. региональными стандартами.) Следовательно, эти операторы выполняют сравнение строк без учета регистра и настроек культурной среды.
Методы класса String
В следующей таблице перечислены некоторые наиболее интересные методы этого класса, сгруппированные по назначению:
Методы работы со строками 


Метод
Структура и перегруженные версии
Назначение


Сравнение строк


Compare()
public static int Compare(string strA, string strB)


public static int Compare(string strA, string strB, bool ignoreCase)
public static int Compare(string strA, string strB, StringComparison comparisonType)
public static int Compare(string strA, string strB, bool ignoreCase, CultureInfo culture)
Статический метод, сравнивает строку strA со строкой strB. Возвращает положительное значение, если строка strA больше строки strB; отрицательное значение, если строка strA меньше строки strB; и нуль, если строки strA и strB равны. Сравнение выполняется с учетом регистра и культурной среды.
Если параметр ignoreCase принимает логическое значение true, то при сравнении не учитываются различия между прописным и строчным вариантами букв. В противном случае эти различия учитываются.
Параметр comparisonType определяет конкретный способ сравнения строк. Класс CultureInfo определен в пространстве имен System.Globalization.
public static int Compare(string strA, int indexA, string strB, int indexB, int length, bool ignoreCase)
public static int Compare(string strA, int indexA, string strB, int indexB, int length, StringComparison comparisonType)
Сравнивает части строк strA и strB. Сравнение начинается со строковых элементов strA[indexA] и strB[indexB] и включает количество символов, определяемых параметром length. Метод возвращает положительное значение, если часть строки strA больше части строки strB; отрицательное значение, если часть строки strA меньше части строки strB; и нуль, если сравниваемые части строк strA и strB равны. Сравнение выполняется с учетом регистра и культурной среды.
Делает то же, что и метод Compare(), но без учета локальных установок
Сравнивает вызывающую строку со строковым представлением объекта value. Возвращает положительное значение, если вызывающая строка больше строки value; отрицательное значение, если вызывающая строка меньше строки value; и нуль, если сравниваемые строки равны
Сравнивает вызывающую строку со строкой strB
Возвращает логическое значение true, если вызывающая строка содержит ту же последовательность символов, что и строковое представление объекта obj. Выполняется порядковое сравнение с учетом регистра, но без учета культурной среды
Возвращает логическое значение true, если вызывающая строка содержит ту же последовательность символов, что и строка value. Выполняется порядковое сравнение с учетом регистра, но без учета культурной среды. Параметр comparisonType определяет конкретный способ сравнения строк
Возвращает логическое значение true, если строка a содержит ту же последовательность символов, что и строка b . Выполняется порядковое сравнение с учетом регистра, но без учета культурной среды. Параметр comparisonType определяет конкретный способ сравнения строк
Возвращает логическое значение true, если вызывающая строка начинается с подстроки value. В противном случае возвращается логическое значение false. Параметр comparisonType определяет конкретный способ выполнения поиска
Возвращает логическое значение true, если вызывающая строка оканчивается подстрокой value. В противном случае возвращает логическое значение false. Параметр comparisonType определяет конкретный способ поиска
Находит первое вхождение заданной подстроки или символа в строке. Если искомый символ или подстрока не обнаружены, то возвращается значение -1
public int IndexOf(string value, int startIndex)
public int IndexOf(char value, int startIndex, int count)
Возвращает индекс первого вхождения символа или подстроки value в вызывающей строке. Поиск начинается с элемента, указываемого по индексу startIndex, и охватывает число элементов, определяемых параметром count (если указан). Метод возвращает значение -1, если искомый символ или подстрока не обнаружен
То же, что IndexOf, но находит последнее вхождение символа или подстроки, а не первое
public int IndexOfAny(char[] anyOf, int startIndex)
Возвращает индекс первого вхождения любого символа из массива anyOf, обнаруженного в вызывающей строке. Поиск начинается с элемента, указываемого по индексу startIndex, и охватывает число элементов, определяемых параметром count (если они указаны). Метод возвращает значение -1, если не обнаружено совпадение ни с одним из символов из массива anyOf. Поиск осуществляется порядковым способом
Возвращает индекс последнего вхождения любого символа из массива anyOf, обнаруженного в вызывающей строке
Метод, возвращающий массив string с присутствующими в данном экземпляре подстроками внутри, которые отделяются друг от друга элементами из указанного массива char или string.
В первой форме метода Split() вызывающая строка разделяется на составные части. В итоге возвращается массив, содержащий подстроки, полученные из вызывающей строки. Символы, ограничивающие эти подстроки, передаются в массиве separator. Если массив separator пуст или ссылается на пустую строку, то в качестве разделителя подстрок используется пробел. А во второй форме данного метода возвращается количество подстрок, определяемых параметром count.
public string[] Split(string[] separator, StringSplitOptions options)
public string[] Split(params char[] separator, int count, StringSplitOptions options)
В двух первых формах метода Split() вызывающая строка разделяется на части и возвращается массив, содержащий подстроки, полученные из вызывающей строки. Символы, разделяющие эти подстроки, передаются в массиве separator. Если массив separator пуст, то в качестве разделителя используется пробел. А в третьей и четвертой формах данного метода возвращается количество строк, ограничиваемое параметром count.
Но во всех формах параметр options обозначает конкретный способ обработки пустых строк, которые образуются в том случае, если два разделителя оказываются рядом. В перечислении StringSplitOptions определяются только два значения: None и RemoveEmptyEntries. Если параметр options принимает значение None, то пустые строки включаются в конечный результат разделения исходной строки. А если параметр options принимает значение RemoveEmptyEntries, то пустые строки исключаются из конечного результата разделения исходной строки.
Строит новую строку, комбинируя содержимое массива строк.
В первой форме метода Join() возвращается строка, состоящая из сцепляемых подстрок, передаваемых в массиве value. Во второй форме также возвращается строка, состоящая из подстрок, передаваемых в массиве value, но они сцепляются в определенном количестве count, начиная с элемента массива value[startIndex]. В обеих формах каждая последующая строка отделяется от предыдущей разделительной строкой, определяемой параметром separator.
Метод, который позволяет удалять все вхождения определенного набора символов с начала и конца текущей строки.
В первой форме метода Trim() из вызывающей строки удаляются начальные и конечные пробелы. А во второй форме этого метода удаляются начальные и конечные вхождения в вызывающей строке символов из массива trimChars. В обеих формах возвращается получающаяся в итоге строка.
Позволяет дополнить строку символами слева.
Позволяет дополнить строку символами справа.
Используется для вставки одной строки в другую, где value обозначает строку, вставляемую в вызывающую строку по индексу startIndex. Метод возвращает получившуюся в итоге строку.
Используется для удаления части строки. В первой форме метода Remove() удаление выполняется, начиная с места, указываемого по индексу startIndex, и продолжается до конца строки. А во второй форме данного метода из строки удаляется количество символов, определяемое параметром count, начиная с места, указываемого по индексу startIndex.
Используется для замены части строки. В первой форме метода Replace() все вхождения символа oldChar в вызывающей строке заменяются символом newChar. А во второй форме данного метода все вхождения строки oldValue в вызывающей строке заменяются строкой newValue.
Делает заглавными все буквы в вызывающей строке.
Делает строчными все буквы в вызывающей строке.
В первой форме метода Substring() подстрока извлекается, начиная с места, обозначаемого параметром startIndex, и до конца вызывающей строки. А во второй форме данного метода извлекается подстрока, состоящая из количества символов, определяемых параметром length, начиная с места, обозначаемого параметром startIndex.
Пример следующей программы использует несколько из вышеуказанных методов:
using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace ConsoleApplication1 < class Program < static void Main(string[] args) < // Сравним первые две строки string s1 = "это строка"; string s2 = "это текст, а это строка"; if (String.CompareOrdinal(s1, s2) != 0) Console.WriteLine("Строки s1 и s2 не равны"); if (String.Compare(s1, 0, s2, 13, 10, true) == 0) Console.WriteLine("При этом в них есть одинаковый текст"); // Конкатенация строк Console.WriteLine(String.Concat("\n" + "Один, два ","три, четыре")); // Поиск в строке // Первое вхождение подстроки if (s2.IndexOf("это") != -1) Console.WriteLine("Слово \"это\" найдено в строке, оно "+ "находится на: позиции", s2.IndexOf("это")); // Последнее вхождение подстроки if (s2.LastIndexOf("это") != -1) Console.WriteLine("Последнее вхождение слова \"это\" находится " + "на позиции", s2.LastIndexOf("это")); // Поиск из массива символов char[] myCh = ; if (s2.IndexOfAny(myCh) != -1) Console.WriteLine("Один из символов из массива ch "+ "найден в текущей строке на позиции ", s2.IndexOfAny(myCh)); // Определяем начинается ли строка с заданной подстроки if (s2.StartsWith("это текст") == true) Console.WriteLine("Подстрока найдена!"); // Определяем содержится ли в строке подстрока // на примере определения ОС пользователя string myOS = Environment.OSVersion.ToString(); if (myOS.Contains("NT 5.1")) Console.WriteLine("Ваша операционная система Windows XP"); else if (myOS.Contains("NT 6.1")) Console.WriteLine("Ваша операционная система Windows 7"); Console.ReadLine(); > > > 

Немного о сравнении строк в C#
Вероятно, из всех операций обработки символьных строк чаще всего выполняется сравнение одной строки с другой. Прежде чем рассматривать какие-либо методы сравнения строк, следует подчеркнуть следующее: сравнение строк может быть выполнено в среде .NET Framework двумя основными способами:

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

В силу отличий способов сравнения строк с учетом культурной среды и порядкового сравнения, а также последствий каждого такого сравнения настоятельно рекомендуется руководствоваться лучшими методиками, предлагаемыми в настоящее время корпорацией Microsoft. Ведь выбор неверного способа сравнения строк может привести к неправильной работе программы, когда она эксплуатируется в среде, отличающей от той, в которой она разработана.
Выбор способа сравнения символьных строк представляет собой весьма ответственное решение. Как правило и без всяких исключений, следует выбирать сравнение строк с учетом культурной среды, если это делается для целей отображения результата пользователю (например, для вывода на экран ряда строк, отсортированных в лексикографическом порядке). Но если строки содержат фиксированную информацию, не предназначенную для видоизменения с учетом отличий в культурных средах, например, имя файла, ключевое слово, адрес веб-сайта или значение, связанное с обеспечением безопасности, то следует выбрать порядковое сравнение строк. Разумеется, особенности конкретного разрабатываемого приложения будут диктовать выбор подходящего способа сравнения символьных строк.
В классе String предоставляются самые разные методы сравнения строк, которые перечислены в таблице выше. Наиболее универсальным среди них является метод Compare(). Он позволяет сравнивать две строки полностью или частично, с учетом или без учета регистра, способа сравнения, определяемого параметром типа StringComparison, а также сведений о культурной среде, предоставляемых с помощью параметра типа CultureInfo.
Те перегружаемые варианты метода Compare(), которые не содержат параметр типа StringComparison, выполняют сравнение символьных строк с учетом регистра и культурной среды. А в тех перегружаемых его вариантах, которые не содержат параметр типа CultureInfo, сведения о культурной среде определяются текущей средой выполнения.
Тип StringComparison представляет собой перечисление, в котором определяются значения, приведенные в таблице ниже. Используя эти значения, можно организовать сравнение строк, удовлетворяющее потребностям конкретного приложения. Следовательно, добавление параметра типа StringComparison расширяет возможности метода Compare() и других методов сравнения, например, Equals(). Это дает также возможность однозначно указывать способ предполагаемого сравнения строк.
В силу имеющих отличий между сравнением строк с учетом культурной среды и порядковым сравнением очень важно быть предельно точным в этом отношении.
Значения, определяемые в перечислении StringComparison 


Значение
Описание


CurrentCulture
Сравнение строк производится с использованием текущих настроек параметров культурной среды


CurrentCultureIgnoreCase
Сравнение строк производится с использованием текущих настроек параметров культурной среды, но без учета регистра


InvariantCulture
Сравнение строк производится с использованием неизменяемых, т.е. универсальных данных о культурной среде


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


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


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


В любом случае метод Compare() возвращает отрицательное значение, если первая сравниваемая строка оказывается меньше второй; положительное значение, если первая сравниваемая строка больше второй; и наконец, нуль, если обе сравниваемые строки равны. Несмотря на то что метод Compare() возвращает нуль, если сравниваемые строки равны, для определения равенства символьных строк, как правило, лучше пользоваться методом Equals() или же оператором ==.
Дело в том, что метод Compare() определяет равенство сравниваемых строк на основании порядка их сортировки. Так, если выполняется сравнение строк с учетом культурной среды, то обе строки могут оказаться одинаковыми по порядку их сортировки, но не равными по существу. По умолчанию равенство строк определяется в методе Equals(), исходя из порядковых значений символов и без учета культурной среды. Следовательно, по умолчанию обе строки сравниваются в этом методе на абсолютное, посимвольное равенство подобно тому, как это делается в операторе ==.
Несмотря на большую универсальность метода Compare(), для простого порядкового сравнения символьных строк проще пользоваться методом CompareOrdinal(). И наконец, следует иметь в виду, что метод CompareTo() выполняет сравнение строк только с учетом культурной среды.
В приведенной ниже программе демонстрируется применение методов Compare(), Equals(), CompareOrdinal(), а также операторов == и != для сравнения символьных строк. Обратите внимание на то, что два первых примера сравнения наглядно демонстрируют отличия между сравнением строк с учетом культурной среды и порядковым сравнением в англоязычной среде:
using System; class Example < static void Main() < string str1 = "alpha"; string str2 = "Alpha"; string str3 = "Beta"; string str4 = "alpha"; string str5 = "alpha, beta"; int result; // Сначала продемонстрировать отличия между сравнением строк // с учетом культурной среды и порядковым сравнением result = String.Compare(str1, str2, StringComparison.CurrentCulture); Console.Write("Сравнение строк с учетом культурной среды: "); if (result < 0) Console.WriteLine(str1 + " меньше " + str2); else if(result >0) Console.WriteLine(str1 + " больше " + str2); else Console.WriteLine(str1 + " равно " + str2); result = String.Compare(str1, str2, StringComparison.Ordinal); Console.Write("Порядковое сравнение строк: "); if (result < 0) Console.WriteLine(str1 + " меньше " + str2); else if(result >0) Console.WriteLine(str1 + " больше " + str2); else Console.WriteLine(str1 + " равно " + str4); // Использовать метод CompareOrdinal() result = String.CompareOrdinal(str1, str2); Console.Write("Сравнение строк методом CompareOrdinal():\n"); if (result < 0) Console.WriteLine(str1 + " меньше " + str2); else if(result >0) Console.WriteLine(str1 + " больше " + str2); else Console.WriteLine(str1 + " равно " + str4); Console.WriteLine(); // Определить равенство строк с помощью оператора == // Это порядковое сравнение символьных строк if (str1 == str4) Console.WriteLine(str1 + " == " + str4); // Определить неравенство строк с помощью оператора != if(str1 != str3) Console.WriteLine(str1 + " != " + str3); if(str1 != str2) Console.WriteLine(str1 + " != " + str2); Console.WriteLine(); // Выполнить порядковое сравнение строк без учета регистра, // используя метод Equals() if(String.Equals(str1, str2, StringComparison.OrdinalIgnoreCase)) Console.WriteLine("Сравнение строк методом Equals() с " + "параметром OrdinalIgnoreCase:\n" + str1 + " равно " + str2); Console.WriteLine (); // Сравнить части строк if(String.Compare(str2, 0, str5, 0, 3, StringComparison.CurrentCulture) > 0) < Console.WriteLine("Сравнение строк с учетом текущей культурной среды:" + "\n3 первых символа строки " + str2 + " больше, чем 3 первых символа строки " + str5); >> >
Выполнение этой программы приводит к следующему результату:


Похожие публикации:

Астра линукс как настроить wi fi
Как отменить действие на компьютере
Как сделать десктопное приложение на python
Как уменьшить вес папки с файлами