Основы Linux от основателя Gentoo. Часть 2 (1/5): Регулярные выражения

Автор оригинала: Daniel Robbins, Chris Houser, Aron Griffis
  • Перевод

Предисловие


Об этом самоучителе


Добро пожаловать в «Азы администрирования», второе из четырех обучающих руководств, разработанных чтобы подготовить вас к экзамену 101 в Linux Professional Institute. В данной части мы рассмотрим как использовать регулярные выражения для поиска текста в файлах по шаблонам. Затем, вы познакомитесь со «Стандартом иерархии файловой системы» (Filesystem Hierarchy Standard или сокр. FHS), также мы покажем вам как находить нужные файлы в вашей системе. После чего, вы узнаете как получить полный контроль над процессами в Linux, запуская их в фоновом режиме, просматривая список процессов, отсоединяя их от терминала, и многое другое. Далее последует быстрое введение в конвейеры, перенаправления и команды обработки текста. И наконец, мы познакомим вас с модулями ядра Linux.



В частности эта часть самоучителя (Часть 2) идеальна для тех, кто уже имеет неплохие базовые знания bash и хочет получить качественное введение в основные задачи администрирования Linux. Если в Linux вы новичок, мы рекомендуем вам сперва закончить первую часть данной серии практических руководств. Для некоторых, большая часть данного материала будет новой, более опытные же пользователи Linux могут счесть его отличным средством подвести итог своим базовым навыкам администрирования.



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



Регулярные выражения


Что такое «регулярное выражение»?


Регулярное выражение (по англ. regular expression, сокр. «regexp» или «regex», в отечестве иногда зовется «регулярка» — прим. пер.) — это особый синтаксис используемый для описания текстовых шаблонов. В Linux-системах регулярные выражения широко используются для поиска в тексте по шаблону, а также для операций поиска и замены на текстовых потоках.



В сравнении с глоббингом


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



Простая подстрока


После этого предостережения, давайте рассмотрим самое основное в регулярных выражениях, простейшую подстроку. Для этого мы воспользуемся «grep», командой, которая сканирует содержимое файла согласно заданному регулярному выражению. grep выводит каждую строчку, которая совпадает с регулярным выражением, игнорируя остальные:



$ grep bash /etc/passwd
operator:x:11:0:operator:/root:/bin/bash root:x:0:0::/root:/bin/bash ftp:x:40:1::/home/ftp:/bin/bash

Выше, первый параметр для grep, это regex; второй — имя файла. grep считывал каждую строчку из /etc/passwd и прикладывал на нее простую regex-подстроку «bash» в поисках совпадения. Если совпадение обнаруживалось, то grep выводил всю строку целиком; в противном случае, строка игнорировалась.



Понимание простой подстроки


В общем случае, если вы ищите подстроку, вы просто можете указать её буквально, не используя каких-либо «специальных» символов. Вам понадобиться особо позаботиться, только если ваша подстрока содержит +, ., *, [, ] или \, в этом случае эти символы должны быть экранированы обратным слешем, а подстрока заключаться в кавычки. Вот несколько примеров регулярных выражений в виде простой подстроки:


  • /tmp (поиск строки /tmp)
  • "\[box\]" (поиск строки [box])
  • "\*funny\*" (поиск строки *funny*)
  • «ld\.so» (поиск строки ld.so)

Метасимволы


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



$ grep dev.sda /etc/fstab
/dev/sda3 / reiserfs noatime,ro 1 1 /dev/sda1 /boot reiserfs noauto,noatime,notail 1 2 /dev/sda2 swap swap sw 0 0 #/dev/sda4 /mnt/extra reiserfs noatime,rw 1 1

В этом примере текст dev.sda не появляется буквально ни в одной из строчек из /etc/fstab. Однако, grep сканирует его не буквально по строке dev.sda, а по dev.sda шаблону. Запомните, что "." будет соответствовать любому единичному символу. Как вы видите, метасимвол "." функционально эквивалентен тому, как работает метасимвол "?" в glob-подстановках.



Использование []


Если мы хотим задать символ конкретнее, чем это делает ".", то можем использовать [ и ] (квадратные скобки), чтобы указать подмножество символов для сопоставления:



$ grep dev.sda[12] /etc/fstab
/dev/sda1 /boot reiserfs noauto,noatime,notail 1 2 /dev/sda2 swap swap sw 0 0

Как вы заметили, в частности, данная синтаксическая конструкция работает идентично конструкции "[]" при glob-подстановке имен файлов. Опять же, в этом заключается одна из неоднозначностей в изучении регулярных выражений: синтаксис похожий, но не идентичный синтаксису glob-подстановок, что сбивает с толку.



Использование [^]


Вы можете обратить значение квадратных скобок поместив ^ сразу после [. В этому случае скобки будут соответствовать любому символу который НЕ перечислен внутри них. И опять, заметьте что [^] мы используем с регулярными выражением, а [!] с glob:



$ grep dev.hda[^12] /etc/fstab
/dev/hda3 / reiserfs noatime,ro 1 1 #/dev/hda4 /mnt/extra reiserfs noatime,rw 1 1

Отличающийся синтаксис


Очень важно отметить, что синтаксис внутри квадратных скобок коренным образом отличается от остальной части регулярного выражения. К примеру, если вы поместите "." внутрь квадратных скобок, это позволит квадратным скобкам совпадать с "." буквально, также как 1 и 2 в примере выше. Для сравнения, "." помещенная вне квадратных скобок, будет интерпретирована как метасимвол, если не приставить "\". Мы можем получить выгоду из данного факта для вывода строк из /etc/fstab которые содержат строку dev.sda, как она записана:



$ grep dev[.]sda /etc/fstab

Также, мы могли бы набрать:



$ grep "dev\.sda" /etc/fstab

Эти регулярные выражения вероятно не удовлетворяют ни одной строчке из вашего /etc/fstab файла.



Матасимвол *


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


  • ab*c совпадает с «abbbbc», но не с «abqc» (в случае glob-подстановки, обе строчки будут удовлетворять шаблону. Вы уже поняли почему?)
  • ab*c совпадает с «abc», но не с «abbqbbc» (опять же, при glob-подстановке, шаблон сопоставим с обоими строчками)
  • ab*c совпадает с «ac», но не с «cba» (в случае глоббинга, ни «ac», ни «cba» не удовлетворяют шаблону)
  • b[cq]*e совпадает с «bqe» и с «be» (glob-подстановке удовлетворяет «bqe», но не «be»)
  • b[cq]*e совпадает с «bccqqe», но не с «bccc» (при глоббинге шаблон точно так же совпадет с первым, но не со вторым)
  • b[cq]*e совпадает с «bqqcce», но не с «cqe» (так же и при glob-подстановке)
  • b[cq]*e удовлетворяет «bbbeee» (но не в случае глоббинга)
  • .* сопоставим с любой строкой (glob-подстановке удовлетворяют только строки начинающиеся с ".")
  • foo.* совпадет с любой подстрокой начинающийся с «foo» (в случае glob-подстановки этот шаблон будет совпадать со строками, начинающимися с четырех символов «foo.»)

Итак, повторим для закрепления: строчка «ac» подходит под регулярное выражение «ab*c» потому, что звездочка также позволяет повторение предшествующего выражения (b) ноль раз. И опять, ценно отметить для себя, что метасимвол * в регулярках интерпретируется совершенно иначе, нежели символ * в glob-подстновках.



Начало и конец строки


Последние метасимволы, что мы детально рассмотрим, это ^ и $, которые используются для сопостовления началу и концу строки, соответственно. Воспользовавшись ^ в начале вашего regex, вы «прикрепите» ваш шаблон к началу строки. В следующием примере, мы используем регулярное выражение ^#, которое удовлетворяет любой строке начинающийся с символа #:

$ grep ^# /etc/fstab
# /etc/fstab: static file system information.
#


Полнострочные регулярки


^ и $ можно комбинировать, для сопоставлений со всей строкой целиком. Например, нижеследующая регулярка будет соответсвовать строкам начинающимся с символа #, а заканчивающимся символом ".", при произвольном количестве символов между ними:



$ grep '^#.*\.$' /etc/fstab
# /etc/fstab: static file system information.


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



Продолжение...



Об авторах


Daniel Robbins


Дэниэль Роббинс — основатель сообщества Gentoo и создатель операционной системы Gentoo Linux. Дэниэль проживает в Нью-Мехико со свой женой Мэри и двумя энергичными дочерьми. Он также основатель и глава Funtoo, написал множество технических статей для IBM developerWorks, Intel Developer Services и C/C++ Users Journal.



Chris Houser


Крис Хаусер был сторонником UNIX c 1994 года, когда присоединился к команде администраторов университета Тэйлора (Индиана, США), где получил степень бакалавра в компьютерных науках и математике. После он работал во множестве областей, включая веб-приложения, редактирование видео, драйвера для UNIX и криптографическую защиту. В настоящий момент работает в Sentry Data Systems. Крис также сделал вклад во множество свободных проектов, таких как Gentoo Linux и Clojure, стал соавтором книги The Joy of Clojure.



Aron Griffis


Эйрон Гриффис живет на территории Бостона, где провел последнее десятилетие работая в Hewlett-Packard над такими проектами, как сетевые UNIX-драйвера для Tru64, сертификация безопасности Linux, Xen и KVM виртуализация, и самое последнее — платформа HP ePrint. В свободное от программирования время Эйрон предпочитает размыщлять над проблемами программирования катаясь на своем велосипеде, жонглируя битами, или болея за бостонскую профессиональную бейсбольную команду «Красные Носки».

Поделиться публикацией
AdBlock похитил этот баннер, но баннеры не зубы — отрастут

Подробнее
Реклама

Комментарии 35

    +1
    DISCLAIMER:
    — Сразу же извиняюсь перед людьми, которые у меня спрашивали о том, когда же я продолжу перевод, а я называл неверные сроки. Спланировать появление лишнего свободного времени, оказалось несколько сложнее, чем планировать время рабочее. =( Спасибо за ваше терпение и ожидание.

    — После небольшого перерыва я вновь продолжаю стабильно переводить по кускам самоучитель с funtoo.org;

    — Остальные материалы с funtoo.org также запланированы к переводу;

    — Есть планы, по завершение перевода второй части, провести ревизию и согласование всего перевода обоих частей в целом, и выложить части у себя на сайте целиком, улучшив при этом форматирование.
      +2
      По поводу регулярных выражений.
      На мой, программистский взгляд, данное введение не претендует ни на полноту, ни на особую ясность в изложении темы регулярных выражений. Впрочем, видимо для «повседневных» нужд и общего ознакомления этого вполне достаточно. Но если вы все же планируете более полноценное знакомство со всей мощью регулярных выражений, или у вас более нетривиальные задачи, и планируете написать что-нибудь вроде этого:
      (?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
      )+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:
      \r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(
      ?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ 
      \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\0
      31]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\
      ](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+
      (?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:
      (?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
      |(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)
      ?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\
      r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[
       \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)
      ?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t]
      )*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[
       \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*
      )(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
      )+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)
      *:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+
      |\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r
      \n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:
      \r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t
      ]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031
      ]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](
      ?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?
      :(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?
      :\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?
      :(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?
      [ \t]))*"(?:(?:\r\n)?[ \t])*)*:(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] 
      \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|
      \\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>
      @,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"
      (?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t]
      )*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
      ".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?
      :[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[
      \]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-
      \031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(
      ?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;
      :\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([
      ^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"
      .\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\
      ]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\
      [\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\
      r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] 
      \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]
      |\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \0
      00-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\
      .|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,
      ;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?
      :[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*
      (?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
      \[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[
      ^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]
      ]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)(?:,\s*(
      ?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
      ".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(
      ?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[
      \["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t
      ])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t
      ])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?
      :\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|
      \Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:
      [^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\
      ]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)
      ?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["
      ()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)
      ?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>
      @,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[
       \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,
      ;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t]
      )*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
      ".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?
      (?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
      \[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:
      \r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[
      "()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])
      *))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])
      +|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\
      .(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
      |(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(
      ?:\r\n)?[ \t])*))*)?;\s*)

      То прочитайте любое другое руководство именно по регулярным выражениям. В сети, и на хабре в том числе, их полно,
      just google it.
        +3
        этой регулярке скорее место в разделе Ненормальное программирование %) какой смысл писать такие небоскребы? да и пост вроде не про это ) про регулярки фридл отлично написал все
          +2
          Хотел привести пример, что регулярки это не только ab*c =) И первое, что пришло в голову, проверка email адреса на валидность строго согласно RFC 822… просто юмор, не воспринимайте серьезно. Разумеется, есть куда более практичные регулярки для этой цели.
            0
            А я то думаю, что-то до боли знакомое :)
          +1
          Не дай боже с таким кодом в работе столкнуться.
            0
            Вообще-то эту задачу можно решить проще и быстрее, если большую часть проверок сделать не через регулярные выражения, а по-старинке. Чрезмерное же у влечение регулярными выражениями до добра не доводит. Найти ошибку в таком весьма не тривиально. А ведь могла бы быть простая и понятная процедура с комментариями на страницу текста. И любой школьник мог бы в ней разобраться и поправить, если нужно.
            0
            я левша люблю картинки))
            habrahabr.ru/blogs/regex/66931/
            • НЛО прилетело и опубликовало эту надпись здесь
                +2
                Сей цикл статей вообще не про Gentoo. =) Просто от разработчика генту.

                Я конечно могу рассказать о том, чем Gentoo отличается от freeBSD, ибо пользуюсь обоими, если кому-то это вообще интересно?
                  0
                  >чем Gentoo отличается от freeBSD
                  я бы послушал, несмотря на постоянно чтение материалов на данную тему
                    0
                    а зачем вы постоянно читаете на эту тему? =) Читай не читай, надо пробовать и исходить из решаемой задачи. Что вас конкретно интересует?, отвечу.
                      0
                      Кстати, а вы не владеете информацией о скорости выполнения Java-кода(64-bit) на обеих платформах?
                        0
                        Увы, джавой не занимаюсь совсем. Могу лишь предположить, что на gentoo будет быстрее, просто лишь на основании того, что из под gentoo многие вещи быстрее. Тут сказывается и медленная UFS и некоторая отсталость bsd ядра по сравнению с linux. Просто там, где нужно выжать максимум производительности на современном железе, я бы не стал брать bsd.
                        0
                        читаю по тому что интересно, генту изучаю уже года полтора, но взялся и за фряху, т.к. она имеет достаточно большое распространение, пока я не могу для себя ответить на вопрос — под какие задачи та или иная система подходит лучше, по этому и послушал бы тех, кто реально пользуется обеими системами и знает в этом толк
                          0
                          Лично мое мнение такое. У фряхи просто есть некоторое сообщество почитателей, и они просто предпочитают фряху не исходя из каких-то объективных причин, а потому что она им более знакома, более любима, более привычна. В конце-концов для многих задач она прекрасно подходит. И генту для этих задач так же прекрасно подходит. И тут просто дело вкуса, дело предпочтений. Но в некоторых случаях генту оказывается гораздо более предпочтительней. Тут и больше пакетов, и более развитая система их установки, и linux ядро в целом более продвинутое, чем bsd, лучше поддержка оборудования… что уж там говорить, это результат того, что сообщество linux пользователей, превосходит по размером сообщество bsd уже давно.
                            0
                            Я тоже выскажу свое имхо. БСД — образец простоты, понятности, четкости конфигов. Но сейчас не про это. Я лично думаю, что какая задача-такая OS. Просто под линукс некоторые задачи выполнить проще и быстрее и только именно для этих задач используется линукс.
                              0
                              Я бы согласился, но одно большое НО. Мало кто довольствуется базовой системой, которую предлагает freeBSD, а уже доустановленный сторонний софт, из портов, использует такие конфиги, какие решил использовать его разработчик. И как правило, конфигурирование стороннего софта, а не базовой системы, отнимает большую часть времени, а тут уж без разницы генту это или бсд.

                              Но в целом да, бсд как ос, проще и понятнее, наверное лучше подходит для начинающих админов. Я сам с нее начинал.
                                0
                                Да и частенько эта простота выходит боком.

                                Помнится нужно было мне прикрутить fpm к php 5.3.0, когда он только появился (ни самого php 5.3, ни fpm в портах при этом не было последний вообще брался из svn). Нагуглить можно было ebuild, были некоторые устаревшие инструкции по сборке, и устаревший образец самодельного порта, но фактически для freebsd ничего толкового не было. И пришлось самим делать свой порт. Ох и навозился я тогда, и я до сих пор недоумеваю, зачем создатель порта должен прикладывать отдельно список устанавливаемых портом файлов, который фактически нужен только для зачистки, почему система сама не может отследить какие файлы были в нее установлены? А когда набор файлов сильно зависит от установленных флагов компиляции, и у тебя нету в этом деле большого опыта, выливается в головную боль. И это было самой маленькой проблемой, из тех, что я столкнулся при создании порта.

                                В генту у тебя просто вообще нету таких проблем. Куча сторонних ебилдов, оверлеи, можешь держать отдельные программы тестинг или даже девелопмент версий, оставляя остальную систему стейбл, и делается это все очень просто. У тебя есть emerge, eselect, equery, etc-update, и работать с набором софта, управлять зависимостями, use-флагами, просто одно удовольствие, есть такая штука как слоты. Никакие фрибсдшные portmaster-ы и portupgrade-ы тут даже близко не валялись. В целом генту взяла лучшие идеи из фрибсд и довела их до, если не совершенства, то нового уровня, с линукс-размахом.

                                Работая с фрибсд я себя чувствую в неких рамках этой самой простоты, и шаг влево, шаг вправо, может стать не тривиальным. Простая, как простые механизмы, но не редко нужно что-то более сложное, и тут наступает облом.
                                  0
                                  Ну я думаю фрибсд не для экспериментов, а для стабильности. А из линуксов да… Генту и Арч -меньшее из зол из-за их гибкости=)
                                    0
                                    Холиварить не хочу. Слишком много копий сломано. Я уважаю Ваше мнение но остаюсь при своем.
                                      0
                                      У меня и мысли не было Вас разубеждать. Обе системы хороши. Просто поделился своим опытом, который не всегда был приятным.
                                        0
                                        Вот если из приятного, то сразу первое, что приходит в глову — это периодика. Ежедневные, ежеденедельные и ежемесячные отчеты на мыло о состоянии системы во фре прямо из коробки, сразу после установки системы, это так приятно. ;-)
                          +2
                          >админ сидит в Gentoo (проблемы с англ)

                          я один вижу в этом эм… противоречие?
                          0
                          Самая рулезная книжка для обучения администрированию лежит по адресу www.admin.com

                          Первое издание, если не ошибаюсь, было ажно в 1995 году, этим летом вышла свежая версия. Обязательно закажу на Амазоне.
                            0
                            Виктор Штонда, издатель:
                            Уникальная книга «Unix и Linux. Руководство системного администратора», 4-е издание, Эви Немет и др. будет издана зимой 2011 года.
                            0
                            Кстати да. У меня есть обе вышедшие по UNIX и Linux. Они во многом дублируют друг друга, но все же действительно полезные. Только, если я не ошибаюсь, о регулярных выражениях там был самый минимум.
                            +1
                            Всю первую часть с удовльствие прочитал, немного упорядочил свои знания :) Будем ждать перевод полного цикла.
                              0
                              Такими мелкими шажками нескоро экзамен получится сдать, мне так кажется.
                              Спасибо за перевод, хоть этого уже и навалом, но чем больше на русском документации по программированию, тем лучше.
                                0
                                Спасибо Вам за переводы.
                                У меня такой вопрос, в разделе с примерами немного не понял вот эту строку:

                                > b[cq]*e удовлетворяет «bbbeee» (но не в случае глоббинга)

                                Разве «bbbeee» удовлетворяет данному регулярному выражению? Ведь * стоит до перед символом 'e', да и, как я понимаю, * действует только на один предшествующий символ, а не на все, т.е. в данном случае любое количество раз могут появляться символы 'c' и 'q' после единственного символа 'b'.

                                Это просто ошибка в мануале или тонкости регулярных выражений и я что-то недопонял? :)
                                  0
                                  b[cq]*e$ бы не удовлетворяло bbbeee, как и ^b[cq]*e, а ^b[cq]*e$ и подавно
                                  но вот b[cq]*e совпадает и с bbbeee и, например, с dfdfdfdfkopjojojhbeejsdfjoisdfjaesfojisefjisoafjesfj

                                  Подумайте над этим ;-)
                                    0
                                    Точно! Как-то упустил из виду, что в строке «bbbeee» есть искомая подстрока «be».

                                    Спасибо :)
                                    0
                                    Только что хотел спросить тоже самое, теперь, хотя бы, чувствую себя не самым невнимательным.

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

                                  Самое читаемое