Разложение спецификаций пути в самый длинный общий префикс + суффикс

Можно вычислить самую длинную общую ведущую подстроку списка строк с этим:

sed -e '1{h;d;}' -e 'G;s,\(.*\).*\n\1.*,\1,;h;$!d'

Который, например, для:

/abc/bcd/cdf
/abc/bcd/cdf/foo
/abc/bcd/chi/hij
/abc/bcd/cdd

возвраты:

/abc/bcd/c

Ограничить его компонентами контура:

sed -e 's,$,/,;1{h;d;}' -e 'G;s,\(.*/\).*\n\1.*,\1,;h;$!d;s,/$,,'

(возвраты /abc/bcd на образце выше).

Нет такого инструмента к моему знанию. Однако можно легко записать такую программу, так как необходимо сделать, определяют самую длинную группу компонентов.

Пример "острота":

echo /abc/bcd/cdf | awk -vpath=/abc/bcd/chi/hij -F/ '{ OFS="\n";len=0; split(path, components); for (i=1; i<=NF; i++) if($i == components[i])len+=1+length($i);else break;print substr($0, 1, len - 1), substr($0, len + 1), substr(path, len + 1);exit;}

Отформатированная версия с комментариями:

$ cat longest-path.awk
#!/usr/bin/awk -f
BEGIN {
    FS="/";   # split by slash
}
{
    len=0;                      # initially the longest path has length 1
    split(path, components);    # split by directory separator (slash)
    for (i=1; i<=NF; i++) {     # loop through all path components
        if ($i == components[i]) {
            len += 1 + length($i);
        } else {
            break;              # if there is a mismatch, terminate
        }
    }
    print substr($0, 1, len - 1);  # longest prefix minus slash
    print substr($0, len + 1);     # remainder stdin
    print substr(path, len + 1);   # remainder path
    exit;                          # only the first line is compared
}
$ echo  /abc/bcd/cdf | ./longest-path.awk -vpath=/abc/bcd/chi/hij
/abc/bcd
cdf
chi/hij

Вот недоброкачественная продукция, которая, кажется, отвечает на вопрос, хорошо используя обычный (стандарт?) средства unix/linux согласно просьбе (хорошо... Я попробовал его только на моем Linux Mageia).

#!/bin/sh
# Compute absolute pathnames common prefix and decompose second one
# Author Babou 2013/05/27 on http://unix.stackexchange.com/questions/67078/
first=`realpath -ms "$1"`
rel=`realpath -ms --relative-to="$1" "$2" | rev`
while [ `basename "$rel"` == '..' ]
do
   first=`dirname "$first"`
   rel=`dirname "$rel"`
done
echo $first + `echo $rel | rev`

И мой набор тестов:

./prefix /abc/bcd/cdf /abc/bcd/chi/hij
./prefix "/abc/bcd/cdf" "/abc/bcd/chi/hij"
./prefix "/ab c/bcd/cdf" "/ab c/bcd/chi/hij"
./prefix "/abc/bcd/cdf" "/abc/bcd/chi/h ij"
./prefix "/" "/"
./prefix "/abc/bcd/" "/abc/bcd/chi/hij"
./prefix "/abc/bcd/cdf" "/abc/bcd/"
./prefix "/abc///zzz/../bcd/cdf" "///abc/bcd//chi/h i j/"
./prefix "/abèc/bcd/cdf" "/abèc/bcd/"

два примера:

$ ./prefix "/abc///zzz/../bcd/cdf" "///abc/bcd//chi/h i j/"
/abc/bcd + chi/h i j
$ ./prefix "/abèc/bcd/cdf" "/abèc/bcd/"
/abèc/bcd + .

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

Я не слишком доволен именами переменных..., но мой первый плохой класс в программировании происходил из-за неудавшегося альфа-преобразования (одно возникновение, о котором забывают). Таким образом, я оставляю его, как.

P.S. Можно хотеть объединить презентацию относительного пути (вторая часть разложения) когда пустой: это может стать или как "/" в одном случае, когда оба пути просто "/".

Stéphane Chazelas уже показал решение, основанное на sed -. Я наткнулся на немного другое выражение sed от ack , которое я настраиваю ниже, чтобы ответить на этот вопрос. В частности, я ограничиваю его компонентами пути и обрабатываю возможность новых строк в компонентах пути. Затем я демонстрирую его использование для разложения спецификаций пути на самые длинные общие ведущие компоненты пути + оставшиеся компоненты пути .

Начнем с выражения ack для sed(Я переключил его на синтаксис ERE ^①):

sed -E '$!{N;s/^(.*).*\n\1.*$/\1\n\1/;D;}' <<"EOF'
/abc/bcd/cdf
/abc/bcd/cdf/foo
/abc/bcd/chi/hij
/abc/bcd/cdd
EOF

⇒ /abc/bcd/c, как и ожидалось. ✔️

Чтобы ограничить его компонентами пути:

sed -E '$!{N;s|^(.*/).*\n\1.*$|\1\n\1|;D;};s|/$||' <<'EOF'
/abc/bcd/cdf
/abc/bcd/cdf/foo
/abc/bcd/chi/hij
/abc/bcd/cdd
EOF

⇒ /abc/bcd, как и ожидалось. ✔️

Обработка компонентов пути с новой строкой

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

a=(
  $'/a\n/b/\nc  d\n/\n\ne/f'
  $'/a\n/b/\nc  d\n/\ne/f'
  $'/a\n/b/\nc  d\n/\ne\n/f'
  $'/a\n/b/\nc  d\n/\nef'
)

Посмотрев, мы можем увидеть, что самый длинный общий ведущий компонент пути равен:

$'/a\n/b/\nc  d\n'

Это можно вычислить и зафиксировать в переменной с помощью следующего:

longest_common_leading_path_component=$(
  printf '%s\0' "${a[@]}" \
    | sed -zE '$!{N;s|^(.*/).*\x00\1.*$|\1\x00\1|;D;};s|/$||' \
    | tr \\0 x # replace trailing NUL with a dummy character ②
)
# Remove the dummy character
longest_common_leading_path_component=${longest_common_leading_path_component%x} 
# Inspect result
echo "${longest_common_leading_path_component@Q}" # ③

Результат:

$'/a\n/b/\nc  d\n'

как и ожидалось. ✔️

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

for e in "${a[@]}"; do
  remainder=${e#"$longest_common_leading_path_component/"}
  printf '%-26s -> %s + %s\n' \
    "${e@Q}" \
    "${longest_common_leading_path_component@Q}" \
    "${remainder@Q}"
done

Результат:

$'/a\n/b/\nc  d\n/\n\ne/f' -> $'/a\n/b/\nc  d\n' + $'\n\ne/f'
$'/a\n/b/\nc  d\n/\ne/f'   -> $'/a\n/b/\nc  d\n' + $'\ne/f'
$'/a\n/b/\nc  d\n/\ne\n/f' -> $'/a\n/b/\nc  d\n' + $'\ne\n/f'
$'/a\n/b/\nc  d\n/\nef'    -> $'/a\n/b/\nc  d\n' + $'\nef'

^{① Я всегда добавляю параметр -Eв sed и grep, чтобы переключить их на синтаксис ERE для лучшей согласованности с другими инструментами/языками, которые я использую, например, awk, bash, perl, javascript и Джава.}

^{② Чтобы сохранить любые завершающие символы новой строки в этой подстановке команд, мы использовали обычную технику добавления фиктивного символа, который впоследствии обрезается. Мы объединили удаление завершающего NUL с добавлением фиктивного символа (, который мы выбралиx)за один шаг, используя tr \\0 x.}

^{③ Расширение ${parameter@Q}приводит к «строке, которая является значением параметра в кавычках в формате, который можно повторно использовать в качестве входных данных». – Справочное руководство по bash . Требуется bash 4.4+(обсуждение). В противном случае вы можете проверить результат, используя один из следующих:}

printf '%q' "$longest_common_leading_path_component"
printf '%s' "$longest_common_leading_path_component" | od -An -tc
od -An -tc < <(printf %s "$longest_common_leading_path_component")
od -An -tc <<<$longest_common_leading_path_component # ④

^{④ Имейте в виду, что здесь -строки добавляют новую строку(обсуждение).}