Не жадное (неохотное) сопоставление регулярных выражений в sed?

Ни базовое, ни расширенное регулярное выражение Posix / GNU не распознает нежадный квантор; вам нужно более позднее регулярное выражение. К счастью, регулярное выражение Perl для этого контекста довольно легко получить:

perl -pe 's|(http://.*?/).*|\1|'

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

Попробуйте это нежадное регулярное выражение [^/]* вместо .*?:

sed 's|\(http://[^/]*/\).*|\1|g'

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

echo "http://www.suon.co.uk/product/1/7/3/" | sed -n 's;\(http://[^/]*\)/.*;\1;p'

Выход:

http://www.suon.co.uk

это:

• не выводить -n
• поиск, соответствие шаблону, замена и печать s/<pattern>/<replace>/p
• используйте ; разделитель команд поиска вместо /, чтобы упростить ввод, поэтому s;<pattern>;<replace>;p
• запомнить соответствие между скобками \( ... \), позже будет доступно с _10 _, _ 11 _...
• совпадение http://
• за которым следует что-либо в скобках [], [ab/] будет означать либо a, либо b, либо /
• первый ^ в [] означает not, поэтому за ним следует что-нибудь, кроме того, что в []
• поэтому [^/] означает что угодно, кроме символа /
• * означает повторение предыдущей группы, поэтому [^/]* означает символы, кроме /.
• пока sed -n 's;\(http://[^/]*\) означает поиск и запоминание http://, за которым следуют любые символы, кроме /, и запоминание того, что вы нашли
• мы хотим искать до конца домена, поэтому остановитесь на следующем /, поэтому добавьте еще / в конце: sed -n 's;\(http://[^/]*\)/', но мы хотим сопоставить остальную часть строки после домена, поэтому добавьте .*
• теперь совпадение, запомненное в группе 1 (\1), является доменом, поэтому замените совпавшую строку на материал, сохраненный в группе \1, и напечатайте: sed -n 's;\(http://[^/]*\)/.*;\1;p'

Если вы хотите включить обратную косую черту после домена, добавьте еще одну обратную косую черту в группу, чтобы запомнить:

echo "http://www.suon.co.uk/product/1/7/3/" | sed -n 's;\(http://[^/]*/\).*;\1;p'

выход:

http://www.suon.co.uk/

Имитация ленивого (не жадного) квантификатора в sed

И все остальные варианты регулярных выражений!

1. Поиск первого вхождения выражения:

   • POSIX ERE (с использованием параметра -r)

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

       (EXPRESSION).*|.
     

     Сед:

       sed -r ‍'s/(EXPRESSION).*|./\1/g' # Global `g` modifier should be on
     

     Пример (поиск первой последовательности цифр) Live demo:

       $ sed -r 's/([0-9]+).*|./\1/g' <<< 'foo 12 bar 34'
     

       12
     

     Как это работает?

     Это регулярное выражение выигрывает от чередования |. В каждой позиции движок пытается выбрать самое длинное совпадение (это стандарт POSIX, за которым также следуют несколько других движков), что означает, что он использует ., пока не будет найдено совпадение для ([0-9]+).*. Но порядок тоже важен.

     

     Поскольку установлен глобальный флаг, движок пытается продолжить сопоставление символа за символом до конца входной строки или нашей цели. Как только первая и единственная группа захвата левой стороны чередования совпадает, (EXPRESSION) остальная часть строки также потребляется .*. Теперь мы сохраняем нашу ценность в первой группе захвата.

   • # P11 # # P12 #

       \(\(\(EXPRESSION\).*\)*.\)*
     

     # P13 #

       sed 's/\(\(\(EXPRESSION\).*\)*.\)*/\3/'
     

     # P14 #

       $ sed 's/\(\(\([0-9]\{1,\}\).*\)*.\)*/\3/' <<< 'foo 12 bar 34'
     

       12
     

     # P15 #

     # P16 #

     # P17 #
2. # P18 # # P19 #

   sed 's/\(END-DELIMITER-EXPRESSION\).*/\1/; \
        s/\(\(START-DELIMITER-EXPRESSION.*\)*.\)*/\1/g'
   

   # P20 #

   foobar start block #1 end barfoo start block #2 end
   

   # P21 # # P22 #

   $ sed 's/\(end\).*/\1/; s/\(\(start.*\)*.\)*/\1/g'
   

   # P23 #

   start block #1 end
   

   # P24 #

   # P25 #

   # P26 #

   # P27 #

Непосредственно отвечая на ваш вопрос

Используя подход №2 (выражение с разделителями), вы должны выбрать два подходящих выражения:

• EDE: [^:/]\/

• SDE: http:

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

$ sed 's/\([^:/]\/\).*/\1/g; s/\(\(http:.*\)*.\)*/\1/' <<< 'http://www.suepearson.co.uk/product/174/71/3816/'

Выход:

http://www.suepearson.co.uk/

Примечание: это не сработает с идентичными разделителями.

sed не поддерживает "не жадный" оператор.

Вы должны использовать оператор «[]», чтобы исключить «/» из совпадения.

sed 's,\(http://[^/]*\)/.*,\1,'

P.S. Нет необходимости использовать обратную косую черту "/".

Нежадное решение для более чем одного символа

Эта ветка действительно старая, но я предполагаю, что она все еще нужна людям. Допустим, вы хотите убить все до самого первого появления HELLO. Вы не можете сказать _2 _...

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

В этом случае мы можем:

s/HELLO/top_sekrit/     #will only replace the very first occurrence
s/.*top_sekrit//        #kill everything till end of the first HELLO

Конечно, при более простом вводе вы можете использовать меньшее слово или, может быть, даже один символ.

HTH!

sed - ненадежное сопоставление от Кристофа Сигхарта

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

Жадное соответствие

% echo "<b>foo</b>bar" | sed 's/<.*>//g'
bar

Нежадное сопоставление

% echo "<b>foo</b>bar" | sed 's/<[^>]*>//g'
foobar

Это можно сделать с помощью cut:

echo "http://www.suepearson.co.uk/product/174/71/3816/" | cut -d'/' -f1-3

другой способ, не используя регулярное выражение, - использовать метод полей / разделителя, например

string="http://www.suepearson.co.uk/product/174/71/3816/"
echo $string | awk -F"/" '{print $1,$2,$3}' OFS="/"

sed безусловно, имеет свое место, но это не одно из них!

Как заметил Ди: просто используйте cut. В этом случае это намного проще и безопаснее. Вот пример, в котором мы извлекаем различные компоненты из URL-адреса с помощью синтаксиса Bash:

url="http://www.suepearson.co.uk/product/174/71/3816/"

protocol=$(echo "$url" | cut -d':' -f1)
host=$(echo "$url" | cut -d'/' -f3)
urlhost=$(echo "$url" | cut -d'/' -f1-3)
urlpath=$(echo "$url" | cut -d'/' -f4-)

дает тебе:

protocol = "http"
host = "www.suepearson.co.uk"
urlhost = "http://www.suepearson.co.uk"
urlpath = "product/174/71/3816/"

Как видите, это гораздо более гибкий подход.

(все кредиты Ди)

sed -E интерпретирует регулярные выражения как расширенные (современные) регулярные выражения

Обновление: -E в MacOS X, -r в GNU sed.

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

sed -r -e ":loop" -e 's|(http://.+)/.*|\1|' -e "t loop"

• -r: использовать расширенное регулярное выражение (для + и неэкранированных круглых скобок)
• ": loop": определите новую метку с именем "loop"
• -e: добавить команды в sed
• "t loop": вернуться к метке "loop", если произошла успешная замена.

Единственная проблема здесь в том, что он также обрежет последний символ-разделитель ('/'), но если он вам действительно нужен, вы все равно можете просто вернуть его после завершения "цикла", просто добавьте эту дополнительную команду в конец предыдущего командная строка:

-e "s,$,/,"

Поскольку вы конкретно заявили, что пытаетесь использовать sed (вместо perl, cut и т. Д.), Попробуйте сгруппировать. Это позволяет избежать нежелательного идентификатора, который потенциально может быть не распознан. Первая группа - это протокол (например, http: //, https: //, tcp: // и т. Д.). Вторая группа - это домен:

echo "http://www.suon.co.uk/product/1/7/3/" | sed "s|^\(.*//\)\([^/]*\).*$|\1\2|"

Если вы не знакомы с группировкой, начните здесь.

Я понимаю, что это старая запись, но кому-то она может пригодиться. Поскольку полное доменное имя не может превышать общую длину 253 символа, замените. * На. \ {1, 255 \}

Вот как надежно выполнять нежадное сопоставление многосимвольных строк с помощью sed. Допустим, вы хотите изменить каждый foo...bar на <foo...bar>, например, этот ввод:

$ cat file
ABC foo DEF bar GHI foo KLM bar NOP foo QRS bar TUV

должен стать таким выводом:

ABC <foo DEF bar> GHI <foo KLM bar> NOP <foo QRS bar> TUV

Для этого вы конвертируете foo и bar в отдельные символы, а затем используете отрицание этих символов между ними:

$ sed 's/@/@A/g; s/{/@B/g; s/}/@C/g; s/foo/{/g; s/bar/}/g; s/{[^{}]*}/<&>/g; s/}/bar/g; s/{/foo/g; s/@C/}/g; s/@B/{/g; s/@A/@/g' file
ABC <foo DEF bar> GHI <foo KLM bar> NOP <foo QRS bar> TUV

В вышеприведенном:

1. s/@/@A/g; s/{/@B/g; s/}/@C/g преобразует { и } в строки-заполнители, которые не могут существовать во входных данных, поэтому эти символы затем доступны для преобразования foo и bar в.
2. s/foo/{/g; s/bar/}/g преобразует foo и bar в { и } соответственно
3. s/{[^{}]*}/<&>/g выполняет нужную операцию - конвертирует foo...bar в <foo...bar>
4. s/}/bar/g; s/{/foo/g преобразует { и } обратно в foo и bar.
5. s/@C/}/g; s/@B/{/g; s/@A/@/g преобразует строки заполнителей обратно в их исходные символы.

Обратите внимание, что приведенное выше не зависит от какой-либо конкретной строки, отсутствующей во входных данных, поскольку она создает такие строки на первом шаге, и не заботится о том, какое вхождение какого-либо конкретного регулярного выражения вы хотите сопоставить, поскольку вы можете использовать {[^{}]*} столько раз, сколько необходимо в выражении, чтобы изолировать фактическое совпадение, которое вы хотите, и / или с помощью оператора числового совпадения seds, например чтобы заменить только 2-е вхождение:

$ sed 's/@/@A/g; s/{/@B/g; s/}/@C/g; s/foo/{/g; s/bar/}/g; s/{[^{}]*}/<&>/2; s/}/bar/g; s/{/foo/g; s/@C/}/g; s/@B/{/g; s/@A/@/g' file
ABC foo DEF bar GHI <foo KLM bar> NOP foo QRS bar TUV

Еще не видели этого ответа, поэтому вот как вы можете сделать это с помощью vi или vim:

vi -c '%s/\(http:\/\/.\{-}\/\).*/\1/ge | wq' file &>/dev/null

Это запускает замену vi :%s глобально (завершающий g), воздерживается от появления ошибки, если шаблон не найден (e), затем сохраняет полученные изменения на диск и завершает работу. &>/dev/null предотвращает кратковременное мигание графического интерфейса пользователя на экране, что может раздражать.

Мне нравится использовать vi иногда для сверхсложных регулярных выражений, потому что (1) perl мертв умирает, (2) vim имеет очень продвинутый механизм регулярных выражений и (3) я ' m уже хорошо знаком с vi регулярными выражениями в моих документах по редактированию повседневного использования.

echo "/home/one/two/three/myfile.txt" | sed 's|\(.*\)/.*|\1|'

не беспокойтесь, я получил это на другом форуме :)

sed 's|\(http:\/\/www\.[a-z.0-9]*\/\).*|\1| тоже работает

Вот что можно сделать с помощью двухэтапного подхода и awk:

A=http://www.suepearson.co.uk/product/174/71/3816/  
echo $A|awk '  
{  
  var=gensub(///,"||",3,$0) ;  
  sub(/\|\|.*/,"",var);  
  print var  
}'  

Вывод: http://www.suepearson.co.uk

Надеюсь, это поможет!

Другая версия sed:

sed 's|/[:alnum:].*||' file.txt

Он соответствует /, за которым следует алфавитно-цифровой символ (а не еще одна косая черта), а также остальные символы до конца строки. Впоследствии он ничего не заменяет (т.е. удаляет).

@Daniel H (относительно вашего комментария к ответу andcoz, хотя и давно): удаление конечных нулей работает с

s,([[:digit:]]\.[[:digit:]]*[1-9])[0]*$,\1,g

речь идет о четком определении условий сопоставления ...

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

Вам нужен префикс до 3-го /, поэтому выберите дважды строку любой длины, не содержащую / и следующую за /, а затем строку любой длины, не содержащую /, а затем сопоставьте / после любой строки, а затем распечатайте выделение. Эта идея работает с любыми символами-ограничителями.

echo http://www.suepearson.co.uk/product/174/71/3816/ | \
  sed -nr 's,(([^/]*/){2}[^/]*)/.*,\1,p'

Используя команды sed, вы можете быстро удалить префикс или выбрать разделитель, например:

echo 'aaa @cee: { "foo":" @cee: " }' | \
  sed -r 't x;s/ @cee: /\n/;D;:x'

Это намного быстрее, чем есть уголь за раз.

Перейти к метке, если предыдущее совпадение было успешным. Добавьте \ n в / перед 1-м разделителем. Удалить до первого \ n. Если был добавлен \ n, перейдите в конец и напечатайте.

Если есть начальные и конечные разделители, просто удалить конечные разделители, пока вы не дойдете до элемента nth-2, который вы хотите, а затем выполните трюк D, удалите после конечного разделителя, перейдите, чтобы удалить, если нет совпадения, удалите до начала разделителя и и Распечатать. Это работает, только если начальные / конечные разделители встречаются парами.

echo 'foobar start block #1 end barfoo start block #2 end bazfoo start block #3 end goo start block #4 end faa' | \
  sed -r 't x;s/end//;s/end/\n/;D;:x;s/(end).*/\1/;T y;s/.*(start)/\1/;p;:y;d'

Если у вас есть доступ к gnu grep, вы можете использовать регулярное выражение perl:

grep -Po '^https?://([^/]+)(?=)' <<< 'http://www.suepearson.co.uk/product/174/71/3816/'
http://www.suepearson.co.uk

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

grep -Po '^https?://([^/]+)\K.*' <<< 'http://www.suepearson.co.uk/product/174/71/3816/'
/product/174/71/3816/