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

    Существует большое количество методов, предназначенных для работы с текстовыми объектами. Эти методы позволяют выполнять самые разные операции со строками. Мы очень кратко обсудим наиболее важные и интересные методы.

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

    Методы, предназначенные для работы с текстом, условно можно разбить на несколько групп в соответствии с типом решаемой задачи. Так, есть методы для выполнения поиска в текстовой строке. Метод indexOf() позволяет выполнять поиск в текстовой строке символа или подстроки. Метод вызывается из объекта текстовой строки, в котором выполняется поиск. Символ или подстрока для поиска передаются аргументом методу. Результатом метод возвращает целое число - индекс первого вхождения в текстовую строку искомого фрагмента или символа. Если при поиске совпадение не найдено (искомая подстрока или символ отсутствуют в исходной текстовой строке), то метод возвращает значение -1. Методу можно передать второй целочисленный аргумент. Если так, то этот аргумент определяет индекс символа в строке, начиная с которого выполняется поиск. Третий необязательный целочисленный аргумент метода IndexOf() определяет количество элементов в строке, по которым выполняется поиск.

    Метод LastIndexOf() похож на метод IndexOf(), но только поиск совпадений начинается с конца строки. Если аргументом методу LastIndexOf() передать подстроку или символ, то результатом метод возвращает индекс последнего вхождения данной подстроки или символа в текст, из которого вызван метод. В случае, если совпадений нет, метод возвращает значение -1. Второй необязательный целочисленный аргумент метода определяет индекс элемента, начиная с которого выполняется поиск совпадений. Поиск выполняется в обратном порядке - от конца в начало текста. Третий необязательный целочисленный аргумент определяет количество элементов, по которым выполняется поиск.

    Методы IndexOfAny() и LastIndexOf Any() подобны методам IndexOf() и LastIndexOf() соответственно, но им первым аргументом передается символьный массив. А поиск выполняется на предмет совпадения хотя бы одного из символов из массива с символом в тексте, из которого вызывается метод. Небольшая иллюстрация к использованию методов IndexOf() и LastIndexOf(), IndexOfAny() и LastIndexOf Any() представлена в примере ниже.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace pr98_1
{
    class Program
    {
        static void Main()
        {
            // Текст, в котором выполняется поиск:
            String txt = "Итак, два плюс два и умножить на два равно шести";
            // Отображение текстового значения:
            Console.WriteLine("Исходный текст:");
            Console.WriteLine("\"{0}\"", txt);
            // Текстовая строка для поиска:
            String str = "два";
            // Отображение текстового значения:
            Console.WriteLine("Строка для поиска:");
            Console.WriteLine("\"{0}\"", str);
            // Переменная для записи значения индекса: 
            int index;
            // Индекс первого вхождения строки в текст: 
            index = txt.IndexOf(str);
            Console.WriteLine("Первое совпадение: {0}", index);
            // Индекс второго вхождения строки в текст: 
            index = txt.IndexOf(str, index + 1);
            Console.WriteLine("Второе совпадение: {0}", index);
            // Индекс последнего вхождения строки в текст: 
            index = txt.LastIndexOf(str);
            Console.WriteLine("Последнее совпадение: {0}", index);

            // Индекс для начала поиска и количество символов: 
            int a = 7, b = 9;
            Console.WriteLine("Поиск с {0}-го индекса по {1} символам:", a, b); 
            // Индекс первого вхождения строки на интервале: 
            index = txt.IndexOf(str, a, b);
            Console.WriteLine("Совпадение на индексе: {0}", index);
            // Изменяем количество символов для поиска:
            b += 3;
            Console.WriteLine("Поиск с {0}-го индекса по {1} символам:", a, b); 
            index = txt.IndexOf(str, a, b);
            Console.WriteLine("Совпадение на индексе: {0}", index);
            // Символ для поиска: 
            char symb = 'а';
            Console.WriteLine("Теперь ищем букву \'{0}\'", symb);
            // Поиск первого совпадения: 
            index = txt.IndexOf(symb);
            Console.WriteLine("Первое совпадение: {0}", index);
            // Поиск второго совпадения: 
            index = txt.IndexOf(symb, index + 1);
            Console.WriteLine("Второе совпадение: {0}", index);
            // Последнее совпадение: 
            index = txt.LastIndexOf(symb);
            Console.WriteLine("Последнее совпадение: {0}", index);
            // Предпоследнее совпадение: 
            index = txt.LastIndexOf(symb, index - 1);
            Console.WriteLine("Предпоследнее совпадение: {0}", index);
            // Поиск на интервале: 
            index = txt.IndexOf(symb, a, b);
            Console.WriteLine("Поиск на интервале индексов от {0} до {1}", 
                  a, a + b - 1); 
            Console.WriteLine("Первое совпадение на интервале: {0}", index);
            // Последнее совпадение на интервале: 
            index = txt.LastIndexOf(symb, b, b + 1);
            Console.WriteLine("Поиск до индекса {0}", b);
            Console.WriteLine("Последнее совпадение на интервале: {0}", index);
            // Новый символ для поиска: 
            symb = 'ы';
            Console.WriteLine("Ищем букву \'{0}\'", symb);
            // Поиск первого совпадения: 
            index = txt.IndexOf(symb);
            Console.WriteLine("Первое совпадение: {0}", index);
            // Массив с буквами для поиска: 
            char[] s = {'ы','а','д'};
            // Отображение символов для поиска:
            Console.Write ("Ищем букву \'{0}\'", s[0]); 
            for(int k = 1; k < s.Length-1; k++) {
                Console.Write(", \'" + s[k] + "\'");
            }
            Console.WriteLine(" или \'" + s[s.Length - 1]+"\':");
            // Первое совпадение: 
            index = txt.IndexOfAny(s);
            Console.WriteLine("Первое совпадение: {0}", index);
            // Второе совпадение: 
            index = txt.IndexOfAny(s, index + 1);
            Console.WriteLine("Второе совпадение: {0}", index);
            // Последнее совпадение: 
            index = txt.LastIndexOfAny(s);
            Console.WriteLine("Последнее совпадение: {0}", index);
            Console.WriteLine("Поиск на интервале индексов от {0} до {1}", 
                 a, a + b - 1); 
            // Первое совпадение на интервале: 
            index = txt.IndexOfAny(s, a, b);
            Console.WriteLine("Первое совпадение на интервале: {0}", index);
            // Последнее совпадение на интервале: 
            index=txt.LastIndexOfAny(s, a + b - 1, b);
            Console.WriteLine("Последнее совпадение на интервале: {0}", index);
            // Задержка:
            Console.ReadLine();
        }
    }
}

    Результат выполнения программы такой.

Рис.1. Поиск по тексту

    В программе текст, в котором выполняется поиск подстрок и символов, записывается в переменную txt (значением является литерал "Итак, два плюс два и умножить на два равно шести"). В переменную stг записывается текст "два". Это строка, которую мы будем искать в тексте. Для записи значения индекса, определяющего позицию строки или символа в тексте, объявляется целочисленная переменная index.

    Первое значение переменной index присваивается командой

  index = txt.IndexOf(str);   . 

  index = txt.IndexOf(str, index + 1);

    Командой

  index = txt.LastIndexOf(str);

    Далее мы используем две целочисленные переменные (переменная а со значением 7 и переменная b со значение 9). Переменные используются в команде

  index = txt.IndexOf(str, a, b);     .

    Значение переменной index после этой команды - индекс первого включения строки str в текст txt, если поиск начинать с индекса со значением а (индекс 7), причем поиск ограничен количеством символов, определяемых значением переменной b (просматривается 9 символов). Получается, что поиск идет по тексту "ва плюс д", в котором нет строки "два". Поэтому метод IndexOf() возвращает значение -1. А вот если мы проделаем ту же операцию, предварительно увеличив значение переменной b на 3 (новое значение этой переменной равно 12), то поиск строки "два" будет выполняться в тексте "ва плюс два ". Такая строка в тексте есть.

    Индекс, определяющий позицию строки, определяется на основе всего текста из переменной txt. Получается значение 15.

    В символьную переменную symb записывается символ 'а', который мы будем искать в тексте txt. Первое появление буквы в тексте определяется индексом, который вычисляется командой

  index=txt.IndexOf(symb);   . 

    В тексте из переменной txt буква 'а' первый раз встречается на третьей позиции (индекс на единицу меньше и равен 2). Индекс позиции, где буква 'а' появляется второй раз, вычисляется командой

  index = txt.IndexOf(symb, index + 1);

    Индекс позиции, в которой имеет место последнее вхождение символьного значения переменной symb в текст txt, вычисляем командой

  index = txt.LastIndexOf(symb); 

  index = txt.LastIndexOf(symb, index - 1);    . 

    Командой

  index = txt.IndexOf(symb, а, b);

Если поиск начинается с символа в позиции с индексом а, а количество проверяемых символов равно b, то это означает, что поиск выполняется на интервале индексов от а до a + b - 1 включительно. Для значений 7 и 12 для переменных а и b получаем интервал индексов от 7 до 18 включительно.

    При выполнении команды

  index = txt.LastIndexOf(symb, b, b + 1); 

    Если символ находится на позиции с индексом b, то от начала текста до этого символа всего находится b + 1 символов. При выполнении инструкции txt.LastIndexOf (symb, b, b + 1) текст из переменной txt просматривается на предмет наличия в нем символа, являющегося значением переменной symb. Текст просматривается, начиная с символа с индексом, определяемым значением второго аргумента b метода LastIndexOf(). Текст просматривается в направлении к началу текста, до первого совпадения. Первое совпадение с конца - это последнее совпадение с начала. Количество символов, которые просматриваются, определяется третьим аргументом метода LastIndexOf(). Значение этого аргумента b + 1 (при значении второго аргумента b) означает, что просматриваются все символы до начала текста.

    Затем переменной symb присваивается новое значение 'ы', и командой

  index = txt.IndexOf(symb); 

    Наконец, мы объявляем и инициализируем символьный массив s, состоящий из трех элементов (буквы 'ы', 'а' и 'д'). В результате выполнения команды

  index = txt.IndexOfAny(s); 

  index=txt.IndexOfAny(s, index + 1); 

    При выполнении команды

  index = txt.LastIndexOfAny(s); 

    Командой

  index = txt.IndexOfAny(s, a, b);

    Команда

  index=txt.LastIndexOfAny(s, a + b - 1, b); 

Метод Contains() позволяет проверить, содержится ли подстрока в строке. Метод вызывается из объекта текста, в котором проверяется наличие подстроки. Подстрока передается аргументом методу. Результатом возвращается логическое значение (тип bool): значение true - если подстрока содержится в тексте, и значение false - если подстрока не содержится в тексте.

    Методы StartsWith() и EndsWith() позволяют проверить, начинается или заканчивается текст определенной подстрокой. Подстрока передается аргументом, а соответствующий метод вызывается из текстового объекта, который проверяется на наличие в начале (метод StartsWith()) или конце (метод EndsWith()) подстроки. Результатом возвращается логическое значение, определяющее наличие или отсутствие подстроки в начале/конце текста.

    На следующем шаге мы продолжим изучение этого вопроса.

Предыдущий шаг Содержание Следующий шаг