Как сравнивать строки в bash

Введение

Регулярные выражения используются для сжатого описания некоторого
множества строк с помощью шаблонов, без необходимости перечисления
всех элементов этого множества или явного написания функции для проверки.
Большинство символов соответствуют сами себе («a» соответствует «a» и т. д.).
Исключения из этого правила называются метасимволами: .

Термин «Регулярные выражения» является переводом с английского словосочетания «Regular expressions».
Перевод не очень точно отражает смысл, правильнее было бы «шаблонные выражения».
Регулярное выражение, или коротко «регулярка», состоит из обычных символов и специальных командных последовательностей.
Например, задаёт любую цифру, а — задает любую последовательность из одной или более цифр.

Работа с регулярками реализована во всех современных языках программирования.
Однако существует несколько «диалектов», поэтому функционал регулярных выражений может различаться от языка к языку.
В некоторых языках программирования регулярками пользоваться очень удобно (например, в питоне), в некоторых — не слишком (например, в C++).

Примеры регулярных выражений

Сила и ответственность

Регулярные выражения, или коротко, регулярки — это очень мощный инструмент.
Но использовать их следует с умом и осторожностью, и только там, где они действительно приносят пользу, а не вред.
Во-первых, плохо написанные регулярные выражения работают медленно.
Во-вторых, их зачастую очень сложно читать, особенно если регулярка написана не лично тобой пять минут назад.
В-третьих, очень часто даже небольшое изменение задачи (того, что требуется найти) приводит к значительному изменению выражения.
Поэтому про регулярки часто говорят, что это write only code (код, который только пишут с нуля, но не читают и не правят).
А также шутят: Некоторые люди, когда сталкиваются с проблемой, думают «Я знаю, я решу её с помощью регулярных выражений.» Теперь у них две проблемы.

Как найти все вхождения слова в строке?

Хорошо, ты никогда не доволен, ты? Итак, давайте рассмотрим, как вы можете найти все вхождения слова в строке.

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

Далее вы узнаете, как найти все вхождения (не только первый матч), используя метод. Вы также можете прочитать мой Учебник в блоге о методе findall () Это объясняет все детали.

>>> import re
>>> re.findall('no', 'nononono')

Ваш код извлекает все соответствующие подстроки. Если вам нужно найти все объекты сопоставления, а не подходящие подстроки, вы можете использовать метод Re.finditer (Pattern, Strattion):

>>> for match in re.finditer('no', 'nonononono'):
	print(match)

	

>>> 

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

Скобочные группы (?:…) и перечисления |

Перечисления (операция «ИЛИ»)

Чтобы проверить, удовлетворяет ли строка хотя бы одному из шаблонов, можно воспользоваться аналогом оператора , который записывается с помощью символа .
Так, некоторая строка подходит к регулярному выражению тогда и только тогда, когда она подходит хотя бы к одному из регулярных выражений или .
Например, отдельные овощи в тексте можно искать при помощи шаблона .

Скобочные группы (группировка плюс квантификаторы)

Зачастую шаблон состоит из нескольких повторяющихся групп. Так, MAC-адрес сетевого устройства обычно записывается как шесть групп из двух шестнадцатиричных цифр, разделённых символами или .
Например, .
Каждый отдельный символ можно задать как , и можно весь шаблон записать так:

{2}{2}{2}{2}{2}{2}

Ситуация становится гораздо сложнее, когда количество групп заранее не зафиксировано.
Чтобы разрешить эту проблему в синтаксисе регулярных выражений есть группировка .
Можно писать круглые скобки и без значков , однако от этого у группировки значительно меняется смысл, регулярка начинает работать гораздо медленнее.
Об этом будет написано ниже.
Итак, если — шаблон, то — эквивалентный ему шаблон.
Разница только в том, что теперь к можно применять квантификаторы, указывая, сколько именно раз должна повториться группа.
Например, шаблон для поиска MAC-адреса, можно записать так:

{2}(?:{2}){5}

Скобки плюс перечисления

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

Например, шаблон
соответствует каждой из строк «он шёл», «он плыл», «тот шёл», «тот плыл», и является синонимом
.

Ещё примеры

(?:\d\d)+

(?:+\d+)+

(?:\+7|8)(?:-\d{2,3}){4}

(?:+)+

\b(?:+)+\b

Как найти все строки, не содержащие точного слова?

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

Это немного сложнее. Я буду показывать вам код сначала и объяснить его потом:

import re
s = '''the answer is 42
the answer: 42
42 is the answer
43 is not
the answer
42'''

for match in re.finditer('^((?!42).)*$', s, flags=re.M):
    print(match)

	
'''

'''

Вы можете увидеть, что код успешно соответствует только линиям, которые не содержат строки Отказ

Как вы можете сделать это?

Общая идея состоит в том, чтобы соответствовать строке, которая не содержит строку « Распечатайте его в оболочку и переходите к следующей строке. Добивается этого легко, возвращая итератор на все объекты матча.

Рисунок Regex соответствует всей линии от первой позиции до последней позиции Отказ Если вам нужен переподготовка к началу линии и Концевые метасимволы, прочитайте это 5-минутное руководство Отказ

Между ними вы соответствуете произвольному количеству персонажей: Quantifier Asterisk делает это для вас. Если вам нужна помощь в понимании квантификатора Asterisk, ознакомьтесь с этим руководством блога.

Какие персонажи вы соответствуете? Только те, где у вас нет негативного слова в вашем поиске. Если вам нужен переподготовка к Lookaheads, проверьте этот урок.

Поскольку сам Lookahead сам не потребляет персонажа, нам нужно использовать его вручную, добавив точку Metacharacter который соответствует всем персонажам, кроме символа Newline Отказ Как оказывается, есть также учебник блога на точечном метачарам.

Наконец, вам нужно определить Флаг, Короче говоря: потому что это позволяет начать и конец Метамарэрэртечники соответствуют также в начале и конце каждой строки (не только в начале и конце каждой строки).

Вместе это регулярное выражение соответствует всем линиям, которые не содержат конкретного слова Отказ

Возвращение к функции re.match()

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

ans = re.match(r"+", str)
print(ans.group(0))

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

Пример вывода:

The

Как видите, регулярное выражение соответствует первому слову, найденному в строке. После слова «The» стоит пробел, который не рассматривается как буква. Таким образом, сопоставление прекращается, и функция возвращает только первое найденное совпадение. Скажем, строка начинается с числа. В этом случае функция match() возвращает нулевое значение, хотя в строке есть буквы, следующие за числом. Например:

str = "1837 was the year when Charles Babbage invented the Analytical Engine"
ans = re.match(r"+", str)
type(ans)

Вышеупомянутое регулярное выражение возвращает null, поскольку функция сопоставления возвращает только первый элемент в строке. Хотя строка содержит алфавиты, ей предшествует число. Следовательно, функция match() возвращает значение null. Этой проблемы можно избежать с помощью функции search().

Диапазоны символов

Символ точки () позволяет нам установить соответствие любому символу. Но иногда нам необходимо быть более конкретными. В этом случае будут полезны диапазоны. Мы указываем диапазон символов, заключая их в квадратные скобки :

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

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

Короткая запись

Допустим, мы хотим найти наличие цифр от 1 до 8. Мы могли бы использовать для поиска следующий диапазон: , но есть вариант получше:

Вы можете комбинировать набор символов вместе с другими символами:

В регулярном выражении, приведенном выше, мы ищем цифры 1, 2, 3, 4 или 9.

Мы также можем объединить несколько наборов. В следующем регулярном выражении мы ищем 1, 2, 3, 4, 5, a, b, c, d, e, f, x:

Использование наборов символов иногда может привести к странному поведению. Например, вы можете использовать диапазон и обнаружить, что ему соответствует символ . Это связано с таблицами символов, которые использует система. В большинстве систем есть таблица символов, в которой сначала идут все строчные буквы, а затем все заглавные (например, ). Однако некоторые системы чередуют строчные и прописные буквы (например, ). Если вы столкнулись с каким-то странным поведением и при этом используете диапазоны, то это первое, что нужно проверить.

Группирование

Мы можем сгруппировать несколько символов в нашем регулярном выражении, используя круглые скобки . Затем мы можем выполнить разные действия с этой группой символов (например, добавить мультипликаторы).

Допустим, нам нужно узнать, упоминается ли какой-то конкретный человек. Его могут звать John Reginald Smith, но второе имя может присутствовать, а может и нет:

Совет: Обратите внимание на пробелы в регулярном выражении, приведенном выше

Важно помнить, что они являются частью вашего регулярного выражения, и вы должны убедиться, что они находятся в нужных местах

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

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

Например, нам нужно найти экземпляры IP-адресов. IP-адрес представляет собой набор из 4 чисел (от 0 до 255), разделенных точками (например, ):

Это уже немного сложнее, поэтому давайте разберемся детально:

    обозначает границу слова;

   здесь мы разбили IP-адрес на 3 части, состоящие из чисел от 0 до 255 + точки + последнее (4-е) число от 0 до 255;

   в скобках мы обрабатываем первые 3 части IP-адреса: указывает на то, что мы ищем от 1 до 3 цифр + точку, следующую за этими цифрами, которую мы не забываем экранировать (). Мы ищем ровно 3 таких последовательности, поэтому указываем мультипликатор сразу за скобками;

   наконец, мы ищем 4-е число, указывая , и обозначаем конечную границу слова ().

Git + 1С. Часть 1. Как подключиться к команде разработки и начать использовать Git

Первая статья из цикла инструкций по работе с Git в 1С-разработке. Рассмотрим, как настроить рабочее место, как получить свою «копию» проекта для разработки и приступить к полезным действиям. Все примеры будут изложены в рамках трёх практических кейсов: 1. Моя команда дорабатывает типовую конфигурацию, использует приватный репозиторий на BitBucket, в котором версионируются внешние отчеты/обработки, расширения конфигураций и правила обмена; 2. Я участвую в стартап-команде, которая разрабатывает свою конфигурацию с использованием Git и GitLab; 3. Я принимаю участие в развитии OpenSource-продукта на GitHub как заинтересованный разработчик (контрибьютор).

Функция ЕСЛИ в MS Excel с несколькими условиями.

Предположим, что у нас есть таблица с результатами сдачи контрольной работы студентами ВУЗа. Результаты контрольной работы оцениваются в баллах. От 0 до 100. Где все, что выше 90 баллов, отлично. Выше 80 баллов, это хорошо. Выше 70 баллов, это удовлетворительно. Ниже 70 баллов, это плохо.

Формула функции ЕСЛИ будет выглядеть вот так:

Где ячейка С3, первая из проверяемых ячеек в столбце Оценка. Далее функция протянута вниз по столбцу Результат, до конца таблицы.

Внимание: в данном случае формула функции ЕСЛИ прописана в ручную, прямо в строе формулы. Таблица выглядит вот так:

Таблица выглядит вот так:

В столбце Результат, в зависимости от количества баллов, функция ЕСЛИ вернула значение, согласно заданному критерию в формуле функции.

Чем трейты отличаются от интерфейсов?

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

Интерфейс — это контракт, в котором говорится, что «этот объект может делать это», тогда как трейт дает объекту возможность делать это.

Другими словами, если код ООП касается планирования и проектирования, то интерфейс — это план, а объект — полностью построенный дом. Между тем, трейты — это просто способ помочь построить дом, спроектированный по плану (интерфейсу).

Интерфейсы — это спецификации, которые можно проверить используя оператор (является ли текущий объект экземпляром указанного класса).

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

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

Например:

Пример

Попробуй сам

Результат выполнения кода:

Добрый день, сэр!Твоя дочь на ужине была хомяком!

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

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

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

Вот как вы срав­ни­ва­е­те стро­ки в Bash.

YAML

if

Вы так­же може­те исполь­зо­вать стро­ку напря­мую вме­сто исполь­зо­ва­ния переменной.

YAML

if

Поз­воль­те нам пока­зать это вам на примерах.

Проверьте, равны ли две строки

Если вы хоти­те про­ве­рить, рав­ны ли две стро­ки, вот пример:

YAML

!/bin/bash
string1=»MyString»
string2=»MyString»
if
then
echo «Строки равны»
else
echo «Строки не равны»
fi

Обра­ти­те вни­ма­ние на пространства
Меж­ду ».

Проверьте, не равны ли строки в Bash

Вме­сто того, что­бы про­ве­рять каче­ство, давай­те сде­ла­ем обрат­ное и про­ве­рим нера­вен­ство. Bash так­же предо­став­ля­ет опе­ра­тор отри­ца­ния, так что вы може­те лег­ко исполь­зо­вать усло­вие «если не рав­но» в сце­на­ри­ях оболочки.

YAML

if

Пол­ный при­мер выгля­дит так:

YAML

!/bin/bash
string1=»MyString»

if
then
echo «Строки не равны»
else
echo «Строки равны»
fi

Проверьте, является ли строка нулевой или пустой в Bash

В отли­чие от неко­то­рых дру­гих язы­ков, таких как C ++, в Bash вы може­те про­ве­рить, явля­ет­ся ли стро­ка пустой или пустой с помо­щью одной команды:

YAML

if

-z фак­ти­че­ски про­ве­ря­ет, рав­на ли дли­на пере­мен­ной нулю или нет. Если пере­мен­ная не уста­нов­ле­на ​​или если она пустая (рав­на «»), дли­на будет рав­на нулю и, сле­до­ва­тель­но, усло­вие вер­нет true.

Пол­ный при­мер мож­но уви­деть здесь:

YAML

!/bin/bash
string1=
string2=»»
if
then
echo «Нулевая строка»
fi
if
then
echo «Строка пуста»
fi

При­ме­ча­ние об исполь­зо­ва­нии оди­нар­ных ско­бок ‘[]’ и двой­ных ско­бок ‘]’ в скрип­тах bash

Вы так­же може­те исполь­зо­вать опе­ра­тор if с двой­ны­ми скоб­ка­ми, напри­мер так:

YAML

if ]

Оди­ноч­ная скоб­ка – это ста­рая кон­вен­ция Posix, и у нее есть неко­то­рые недо­стат­ки. Если вы не исполь­зу­е­те двой­ные кавыч­ки вокруг пере­мен­ных, а пере­мен­ная не опре­де­ле­на, она исчез­нет из кода и при­ве­дет к син­так­си­че­ской ошибке.

YAML

if

Если пере­мен­ная $ string1 пуста или не опре­де­ле­на в при­ве­ден­ном выше коде, эта стро­ка ста­нет эквивалентной

YAML

if

Группирующие скобки (…) и match-объекты в питоне

Match-объекты

Если функции , не находят соответствие шаблону в строке, то они возвращают , функция возващает пустой итератор.
Однако если соответствие найдено, то возвращается -объект.
Эта штука содержит в себе кучу полезной информации о соответствии шаблону.
В отличие от предыдущих функций, возвращает «простой и понятный» список соответствий.
Полный набор атрибутов -объекта можно посмотреть в , а здесь приведём самое полезное.

Группирующие скобки

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

import re
pattern = r'\s*(+)(\d+)\s*'
string = r'---   Опять45   ---'
match = re.search(pattern, string)
print(f'Найдена подстрока >{match.group(0)}< с позиции {match.start(0)} до {match.end(0)}')
print(f'Группа букв >{match.group(1)}< с позиции {match.start(1)} до {match.end(1)}')
print(f'Группа цифр >{match.group(2)}< с позиции {match.start(2)} до {match.end(2)}')
###
# Найдена подстрока >   Опять45   < с позиции 3 до 16
# Группа букв >Опять< с позиции 6 до 11
# Группа цифр >45< с позиции 11 до 13

Тонкости со скобками и нумерацией групп.

Если к группирующим скобкам применён квантификатор (то есть указано число повторений), то подгруппа в match-объекте будет создана только для последнего соответствия.
Например, если бы в примере выше квантификаторы были снаружи от скобок , то вывод был бы таким:

Найдена подстрока >   Опять45   < с позиции 3 до 16
Группа букв >ь< с позиции 10 до 11
Группа цифр >5< с позиции 12 до 13

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

import re
pattern = r'((\d)(\d))((\d)(\d))'
string = r'123456789'
match = re.search(pattern, string)
print(f'Найдена подстрока >{match.group(0)}< с позиции {match.start(0)} до {match.end(0)}')
for i in range(1, match.groups()+1):
    print(f'Группа №{i} >{match.group(i)}< с позиции {match.start(i)} до {match.end(i)}')
###
Найдена подстрока >1234< с позиции 0 до 4
Группа №1 >12< с позиции 0 до 2
Группа №2 >1< с позиции 0 до 1
Группа №3 >2< с позиции 1 до 2
Группа №4 >34< с позиции 2 до 4
Группа №5 >3< с позиции 2 до 3
Группа №6 >4< с позиции 3 до 4

Группы и

Если в шаблоне есть группирующие скобки, то вместо списка найденных подстрок будет возвращён список кортежей, в каждом из которых только соответствие каждой группе. Это не всегда происходит по плану, поэтому обычно нужно использовать негруппирующие скобки .

import re
print(re.findall(r'(+)(\d*)', r'foo3, im12, go, 24buz42'))
# -> 

Группы и

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

import re
print(re.split(r'(\s*)([+*/-])(\s*)', r'12  +  13*15   - 6'))
# -> 

Как сопоставить слово в строке (слово границы \ b)?

Итак, как мы можем решить проблему, что точное совпадение словом также будет получать соответствующие подстроки, которые происходят в любой точке строки?

Вот пример:

>>> 'no' in 'nobody knows'
True

И еще один пример:

>>> re.search('see', 'dfjkyldsssseels')

Что, если вы хотите подобрать только целые слова – не точные подстроки? Ответ прост: используйте слово границы Metacharacter Отказ Этот метачаренок совпадает с началом и концом каждого слова – но он ничего не потребляет. Другими словами, он просто проверяет, начинается ли слово или заканчивается в этой позиции (путем проверки пробелов или символов без слова).

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

>>> import re
>>> re.search(r'\bno\b', 'nobody knows')
>>> 
>>> re.search(r'\bno\b', 'nobody knows nothing - no?')

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

В результате Regex не совпадает в строке Но это соответствует строке Отказ

Обратите внимание, что мы используем сырую строку Чтобы написать регулярное выражение, чтобы побегнуть последовательность работает в строке. Без сырой струны Python предположил бы, что это неизмеренная обратная косая черта следуют персонаж Отказ С сырой строкой все обратные косания будут просто так: обратные косание

Затем двигатель REGEX затем интерпретирует два символа в виде одного специального Metacharacter: граница слова Отказ

Но что, если вам все равно, является ли слово верхним или строчным или заглавным? Другими словами:

Для тех, кому мало…

Итак, лет этак эндцать назад программисты решили упростить поиск, замену и проверку на соответвие различных строк, т.к. им, полагаю, надоело каждый раз писать что-то типа:

Если Сред(стрДата,1,1) < "0" ИЛИ Сред(стрДата,1,1) > "9" Тогда Ошибка = Истина;
КонецЕсли;

Если Сред(стрДата,2,1) < "0" ИЛИ Сред(стрДата,2,1) > "9" Тогда Ошибка = Истина;
КонецЕсли;

Если Сред(стрДата,3,1) <> "." Тогда Ошибка = Истина;
КонецЕсли;

//...

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

Ошибка = НЕ ПроверитьСтроку(СтрДата, "\d{2}\.\d{2}\.\d{4}");

Да, грамотным разработчикам стало ой как просто. Но что делать остальным? Правилный ответ, конечно, — учиться, учиться и еще раз  учиться! )))

Итак, самое простое, что нужно, чтобы освоить шаблоны проверки:

. — любой символ

+ — один или более раз, пример «.+» — один или более любой символ.

* — ноль или более раз, пример «.*» — любое количество любых символов (даже ни одного).

— символ от m до n, пример: «+» — одна или более цифр(а).

\d — цифра, пример \d+ — одна или более цифр(а).

\D — не цифра.

\s — пробельный символ — ТАБ, пробел, перенос строки, возврат каретки и т.п.

\S — непробельный символ.

\w — буква, цифра, подчеркивание.

\W — не буква, не цифра и не подчеркивание соответственно.

^ — начало текста, например «^\d+» — строка начинается с цифры.

$ — конец текста, например «\D+$» — строка заканчивается НЕ цифрой.

{m,n} — шаблон для от m до n символов, например «\d{2,4}» — от двух до четырех цифр. Можно указать одну и всего цифру для строгого соответвия.

Поиск шаблонов в строке

Одна из наиболее распространенных задач при обработке текста – это поиск, содержит ли строка определенный шаблон или нет. Например, вы можете захотеть выполнить операцию над строкой при условии, что строка содержит число. Или вы можете проверить пароль, убедившись, что он содержит числа и специальные символы. Операция «сопоставления» RE предоставляет эту возможность.

Python предлагает две примитивные операции, основанные на регулярных выражениях: функция re.match() проверяет соответствие шаблону в начале строки, тогда как re.search() проверяет соответствие шаблону в любом месте строки. Давайте посмотрим, как можно использовать эти функции:

Операторы массивов PHP

Операторы массивов PHP используются для сравнения массивов.

В следующей таблице приведён список операторов, работающих с массивами PHP:

Практические примеры

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

▍Подсчёт количества файлов

Напишем bash-скрипт, который подсчитывает файлы, находящиеся в директориях, которые записаны в переменную окружения 
PATH. Для того, чтобы это сделать, понадобится, для начала, сформировать список путей к директориям. Сделаем это с помощью sed, заменив двоеточия на пробелы:

$ echo $PATH | sed ‘s/:/ /g’

Команда замены поддерживает регулярные выражения в качестве шаблонов для поиска текста. В данном случае всё предельно просто, ищем мы символ двоеточия, но никто не мешает использовать здесь и что-нибудь другое — всё зависит от конкретной задачи.Теперь надо пройтись по полученному списку в цикле и выполнить там необходимые для подсчёта количества файлов действия. Общая схема скрипта будет такой:

mypath=$(echo $PATH | sed ‘s/:/ /g’)
for directory in $mypath

do

done

Теперь напишем полный текст скрипта, воспользовавшись командой 
ls для получения сведений о количестве файлов в каждой из директорий:

#!/bin/bash
mypath=$(echo $PATH | sed ‘s/:/ /g’)
count=0
for directory in $mypath
do
check=$(ls $directory)
for item in $check
do
count=$
done
echo «$directory — $count»
count=0
done

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

Подсчёт файлов

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

▍Проверка адресов электронной почты

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

username@hostname.com

Имя пользователя, 
username, может состоять из алфавитно-цифровых и некоторых других символов. А именно, это точка, тире, символ подчёркивания, знак «плюс». За именем пользователя следует знак @.

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

^(+)@

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

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

(+)

Имя домена верхнего уровня подчиняется особым правилам. Тут могут быть лишь алфавитные символы, которых должно быть не меньше двух (например, такие домены обычно содержат код страны), и не больше пяти. Всё это значит, что шаблон для проверки последней части адреса будет таким:

\.({2,5})$

Прочесть его можно так: «Сначала должна быть точка, потом — от 2 до 5 алфавитных символов, а после этого строка заканчивается».

Подготовив шаблоны для отдельных частей регулярного выражения, соберём их вместе:

^(+)@(+)\.({2,5})$

Теперь осталось лишь протестировать то, что получилось:

$ echo «name@host.com» | awk ‘/^(+)@(+)\.({2,5})$/{print $0}’
$ echo «name@host.com.us» | awk ‘/^(+)@(+)\.({2,5})$/{print $0}’

Проверка адреса электронной почты с помощью регулярных выражений

То, что переданный awk текст выводится на экран, означает, что система распознала в нём адрес электронной почты.

Заключение

Резюмируем то, что мы узнали:

    — соответствует любому символу;

    — совпадает с символом из диапазона, содержащемуся в квадратных скобках;

    — соответствует символам, которые не входят в диапазон, содержащийся в квадратных скобках;

    — совпадение 0 или более раз с указанным элементом;

    — совпадение 1 или более раз с указанным элементом;

    — совпадение 0 или 1 раз с указанным элементом;

    — точное совпадение раз с указанным элементом;

    — точное совпадение от до раз с указанным элементом;

    — точное совпадение или более раз с указанным элементом;

    — экранирование или отмена специального значения указанного символа.