Методы RegExp и String для работы с регулярными выражениями

Методы RegExp и String для работы с регулярными выражениями

Здравствуйте! Продолжаем  разбираться с регулярными выражениями и в этом уроке мы с вами рассмотрим  собственно методы, предназначенные для работы с регулярными выражениями.  Это будут как методы регулярных выражений, так и методы строк. Поскольку структура встроенных методов немного  слегка запутана, то  мы  для начала рассмотрим их по отдельности, а после –  способы решения задач с ними.

Методы регулярных выражений

 

 

Метод  str.search(reg)

Этот метод уже встречался нам в первом уроке

Он вернет позицию первого совпадения или -1, если ничего не найдено.

 var str1 = "Люблю регулярки я, но странною любовью"; alert( str.search( /лю/i ) ); // 0

У этого метода есть одно, но существенное ограничение –  это то, что он всегда ищет только первое совпадение.

Но  к счастью имеются  другие методы, которые лишены подобного недостатка.

Метод str.match(reg) без флага g

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

В этом случае  метод str.match(reg) найдет только одно, первое совпадение, как и предыдущий метод search.

Результат работы метода  – это массив,  который состоит из этого самого  совпадения, с свойствами index – позиция, на которой оно обнаружено и input – строка, в которой искали.

Например:

 var str1 = "АЙ-ай-ай"; var result1 = str1.match( /ай/i ); alert( result[0] ); // АЙ (совпадение) alert( result1.index ); // 0 (позиция) alert( result1.input ); // АЙ-ай-ай (вся поисковая строка)

Следует отметить, что у этого массива не всегда только один элемент.

Если часть шаблона  заключить в скобки, то она становится  отдельным элементом массива.

Например:

var str1 = "javascript - это язык программирования"; var result1 = str1.match( /JAVA(SCRIPT)/i ); alert( result1[0] ); // javascript (всё совпадение полностью) alert( result[1] ); // script (часть совпадения, соответствующая скобкам) alert( result.index ); // 0 alert( result.input ); // javascript - это такой язык

Используя флаг i поиск не  будет обращать  внимание на регистр букв, поэтому найдет javascript. А часть строки, соответствующая SCRIPT,  будет выделена в отдельный элемент массива.

 

Метод str.match(reg) с флагом g

При наличии же  флага g, вызов match вернет массив из всех совпадений.

Никаких свойств у массива  нет,  да и скобки дополнительных элементов не создают.

Читайте также  Квантификаторы регулярных выражений

Например:

    
var str1 = "АЙ-яа-ай"; var result1 = str1.match( /ай/ig ); alert( result1 ); // АЙ, ай, ай

Пример со скобками:

                                        
var str1 = "javascript - это язык программирования"; var result1 = str1.match( /JAVA(SCRIPT)/gi ); alert( result1[0] ); // javascript alert( result1.length ); // 1 alert( result1.index ); // undefined

Из примера видно, что элемент в массиве один, и свойства index также нет. Это и является  особенностью глобального поиска при помощи match – он  вернет все совпадения.

А вот в случае, если совпадений найдено  не было, match вернет null

Обращаю ваше внимание  на то что возвращается именно null, а не пустой массив. Это важно понимать, чтобы не попасть вот таккую ловушку:

var str = "Ой-йой-йой";
// результат match не всегда возвращает массив!
alert(str1.match(/мю/gi).length) // ошибка! нет свойства length у null

Метод str.split(reg|substr, limit)

Данный метод разбивает строку в массив по разделителю – регулярному выражению regexp или подстроке substr.

Со строками мы используем метод split:

alert('22-54-66'.split('-')) // [22, 54, 66]

Можно также  передать в него и регулярку, тогда он разобьёт строку по всем совпадениям.

Тот же пример с регуляркой:

alert('22-54-66'.split(/-/)) // [22, 54, 66]

Метод str.replace(reg, str|func)

А это своего рода швейцарский нож для работы со строками,  для поиска и замены  строки любого уровня сложности.

Его  самое простейшее применение – поиск и замена подстроки в строке, вот так:

// заменить дефис на двоеточие
alert('22-54-66'.replace("-", ":")) // 22:54:66

При вызове  без флага g со строкой замены replace всегда заменяет только первое совпадение.

Если вы хотите  заменить все совпадения,  то следует  использовать для поиска не строку «-«, а регулярку /-/g, причём именно  обязательно с флагом g:

                               
// заменим дефис на двоеточие alert( '22-54-66'.replace( /-/g, ":" ) ) // 22:54:66

В строке для замены  также можно использовать и  специальные символы:

Спецсимволы Действие в строке замены
$$ Вставит «$».
$& Вставит всё найденное совпадение.
$` Вставит часть строки до совпадения.
$’ Вставит часть строки после совпадения.
$*n* где n — двузначное число, которое  обозначает n-ю по счёту скобку, если считать слева-направо.

Вот пример использования скобок и $1, $2:

var str = "Василий Чапаев";
alert(str.replace(/(Василий) (Чапаев)/, '$2, $1')) // Чапаев, Василий

Ещё один пример, с использованием $&:

var str = "Василий Чапаев";
alert(str.replace(/Василий Чапаев/, 'Великий $&!')) // Великий Василий Чапаев!

А вот для ситуаций, которые требуют  «умной» замены, в качестве 2-го аргумента предусмотрена функция.

Читайте также  Начало строки ^ и конец $ в регулярных выражениях

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

Например:

let i = 0;
// заменить каждое вхождение "ой" на результат вызова функции
alert("АЙ-Ай-ай".replace(/ай/gi, function() {
  return ++i;
})); // 1-2-3

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

Эта функция получает следующие аргументы:

  1. str – совпадение,
  2. p1, p2, …, pn – содержимое скобок,
  3. offset – позиция, на которой было найдено совпадение,
  4. s – исходная строка.

Если скобок в регулярном выражении нет, то у функции всегда будет ровно три аргумента: replacer(str, offset, s).

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

// вывести и заменить все совпадения
function replacer(str, offset, s) {
  alert( "Найдено: " + str + " на  такой позиции: " + offset + " в строке: " + s );
  return str.toLowerCase();
}

var result = "АЙ-Ай-ай".replace(/ай/gi, replacer);
alert( 'Результат: ' + result ); // Результат: ай-ай-ай

А если с двумя скобочными выражениями – аргументов уже пять:

function replacer(str, name, surname, offset, s) {
  return surname + ", " + name;
}
var str = "Василий Чапаев";
alert(str.replace(/(Василий) (Чапаев)/, replacer)) // Пупкин, Василий

Функция – это  есть самый мощный инструмент для замены.

Метод  regexp.test(str)

Теперь  давайте рассмотрим методы класса  регулярных выражений RegExp.

Метод test проверяет, на совпадение в строке шаблону регулярного выражения  str. Возвращает true/false. Это логический метод, поэтому используется с логическими операторами.

Работает, по сути, так же, как и проверка search, например:

                       
var str = "Люблю регулярки я, но странною любовью"; 
if(/лю/.test(str1)) {
   console.log('Совпадение найдено');
}
else {
  console.log('Совпадение не найдено');
}

Метод  regexp.exec(str)

Для поиска мы уже рассмотрели методы:

  • search – ищет индекс
  • match – если регулярка без флага g – ищет совпадение с подрезультатами в скобках
  • match – если регулярка с флагом g – ищет все совпадения, но без скобок.

И метод regexp.exec дополняет их. Он позволяет искать и все совпадения и скобки в них.

И ведёт он  себя по-разному, в зависимости от наличия  флага g.

  • Если флага g нет, то regexp.exec(str) ищет и возвращает 1-е совпадение, как  str.match(reg).
  • Если же флаг g есть, то вызов regexp.exec возвращает первое совпадение и запоминает его в свойстве regexp.lastIndex.  И последующий поиск он начнёт уже с этой позиции. Если совпадений было  не найдено, то regexp.lastIndex  устанавливается в ноль.
Читайте также  Скобочные группы в регулярных выражениях

Это  можно использовать  для поиска всех совпадений в цикле:

var str1 = 'JavaScript современный язык программирования. Я люблю JavaScript';
var regexp1 = /javascript/ig;
var result1;
alert( "Начальное значение lastIndex: " + regexp1.lastIndex );
while (result1 = regexp1.exec(str1)) {
  alert( 'Найдено: ' + result1[0] + ' на позиции:' + result1.index );
  alert( 'Свойство lastIndex: ' + regexp1.lastIndex );
}
alert( 'Конечное значение lastIndex: ' + regexp1.lastIndex );

Здесь цикл будет продолжается до тех пор, пока regexp1.exec не вернёт null, что означает «совпадений больше нет».

Найденные результаты последовательно помещаются в result1, со свойствами result1.index и result1.input.

Поиск с нужной позиции

Можно также  заставить regexp.exec искать с нужной позиции, если  lastIndex выставить  вручную:

var str1 = 'JavaScript современный язык программирования. Я люблю JavaScript';
var regexp1 = /javascript/ig;
regexp1.lastIndex = 40;
alert( regexp1.exec(str1).index ); // 49, поиск начат с 40-й позиции

Итого

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

Для поиска только одного совпадения:
  • Найти позицию 1-го совпадения – str.search(reg).
  • Найти само совпадение – str.match(reg).
  • Проверить, есть ли хоть одно совпадение – regexp.test(str) или str.search(reg) != -1.
  • Найти совпадение с нужной позиции – regexp.exec(str), начальную позицию поиска задать в regexp.lastIndex.
Для поиска  абсолютно всех совпадений:
  • Найти массив совпадений – str.match(reg), с флагом g.
  • Получить все совпадения, с подробной информацией о каждом – regexp.exec(str) с флагом g, в цикле.

Для поиска-и-замены: : — Замена на другую строку или результат функции — `str.replace(reg, str|func)`

Для разбивки строки на части:
  • str.split(str|reg)

Зная эти методы, мы уже можем использовать регулярные выражения.

Смотрите видео по методам регулярных выражений

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

Плюсануть
Поделиться

Об авторе

admin administrator

Сообщить об опечатке

Текст, который будет отправлен нашим редакторам: