Как рекурсивно перечислить все каталоги в определенном месте в ширину?
Вопрос
Здесь важен список в ширину.Кроме того, было бы неплохо ограничить глубину поиска.
$ find . -type d
/foo
/foo/subfoo
/foo/subfoo/subsub
/foo/subfoo/subsub/subsubsub
/bar
/bar/subbar
$ find . -type d -depth
/foo/subfoo/subsub/subsubsub
/foo/subfoo/subsub
/foo/subfoo
/foo
/bar/subbar
/bar
$ < what goes here? >
/foo
/bar
/foo/subfoo
/bar/subbar
/foo/subfoo/subsub
/foo/subfoo/subsub/subsubsub
Я хотел бы сделать это, используя однострочник bash, если это возможно.Если бы существовала оболочка javascript, я бы представил себе что-то вроде
bash("find . -type d").sort( function (x) x.findall(/\//g).length; )
Решение
А find
командная поддержка -printf
вариант, который распознает множество заполнителей.
Одним из таких заполнителей является %d
который отображает глубину данного пути относительно того, где find
начал.
Поэтому вы можете использовать следующую простую однострочную строку:
find -type d -printf '%d\t%P\n' | sort -r -nk1 | cut -f2-
Это довольно просто и не зависит от тяжелых инструментов, таких как perl
.
Как это работает:
- он внутренне генерирует список файлов, каждый из которых отображается в виде строки из двух полей.
- первое поле содержит глубину, которая используется для (обратной) числовой сортировки, а затем отрезается
- В результате получается простой список файлов, по одному файлу в строке, в самом глубоком порядке.
Другие советы
Если вы хотите сделать это с помощью стандартных инструментов, должен работать следующий конвейер:
find . -type d | perl -lne 'print tr:/::, " $_"' | sort -n | cut -d' ' -f2
То есть,
- найдите и распечатайте все каталоги здесь подробно в первую очередь
- подсчитайте количество косых черт в каждом каталоге и добавьте его к пути
- сортировка по глубине (т. е. количеству косых черт)
- извлеките только путь.
Чтобы ограничить найденную глубину, добавьте аргумент -maxeep в команду поиска.
Если вы хотите, чтобы каталоги были перечислены в том же порядке, в котором их выводит команда find, используйте «sort -n -s» вместо «sort -n»;флаг «-s» стабилизирует сортировку (т. е. сохраняет порядок ввода среди элементов, которые сравниваются одинаково).
Я не думаю, что вы могли бы сделать это с помощью встроенных утилит, поскольку при перемещении по иерархии каталогов вам почти всегда нужен поиск в глубину, либо сверху вниз, либо снизу вверх.Вот скрипт Python, который обеспечит поиск в ширину:
import os, sys
rootdir = sys.argv[1]
queue = [rootdir]
while queue:
file = queue.pop(0)
print(file)
if os.path.isdir(file):
queue.extend(os.path.join(file,x) for x in os.listdir(file))
Редактировать:
- С использованием
os.path
-модуль вместоos.stat
-функция иstat
-модуль. - С использованием
list.pop
иlist.extend
вместоdel
и+=
операторы.
Я считаю, что это лучшее решение, чем ранее упомянутые.Он включает в себя grep и тому подобное, а также цикл, но я считаю, что он работает очень хорошо, особенно в тех случаях, когда вам нужна буферизация строк, а не полная буферизация поиска.
Это более ресурсоемко из-за:
- Много разветвлений
- Множество находок
- Каждый каталог до текущей глубины обнаруживается командой find столько раз, сколько общая глубина файловой структуры (это не должно быть проблемой, если у вас практически любой объем оперативной памяти...)
Это хорошо, потому что:
- Он использует bash и базовые инструменты GNU.
- Его можно сломать, когда захочешь (как будто мимо пролетает то, что искал)
- Он работает построчно, а не по каждому поиску, поэтому последующим командам не нужно ждать поиска и сортировки.
- Он работает на основе фактического разделения файловой системы, поэтому, если у вас есть каталог с косой чертой, он не будет отображаться глубже, чем есть;если у вас настроен другой разделитель путей, все равно все в порядке.
#!/bin/bash depth=0 while find -mindepth $depth -maxdepth $depth | grep '.' do depth=$((depth + 1)) done
Вы также можете легко (?) поместить его в одну строку:
depth=0; while find -mindepth $depth -maxdepth $depth | grep --color=never '.'; do depth=$((depth + 1)); done
Но я предпочитаю небольшие сценарии печатанию...
Вы можете использовать команду «Найти», найти/path/to/dir -type d, так что ниже примеры примеров каталогов в текущем каталоге:
find . -type d
Я пытался найти способ сделать это с помощью find
но, похоже, у него нет ничего похожего на -breadth
вариант.Если не считать написания патча для него, попробуйте следующее заклинание оболочки (для bash):
LIST="$(find . -mindepth 1 -maxdepth 1 -type d)";
while test -n "$LIST"; do
for F in $LIST; do
echo $F;
test -d "$F" && NLIST="$NLIST $(find $F -maxdepth 1 -mindepth 1 -type d)";
done;
LIST=$NLIST;
NLIST="";
done
Я как бы случайно наткнулся на это, поэтому не знаю, работает ли это в целом (я тестировал его только на конкретной структуре каталогов, о которой вы спрашивали)
Если вы хотите ограничить глубину, поместите переменную-счетчик во внешний цикл, например (я также добавляю комментарии):
# initialize the list of subdirectories being processed
LIST="$(find . -mindepth 1 -maxdepth 1 -type d)";
# initialize the depth counter to 0
let i=0;
# as long as there are more subdirectories to process and we haven't hit the max depth
while test "$i" -lt 2 -a -n "$LIST"; do
# increment the depth counter
let i++;
# for each subdirectory in the current list
for F in $LIST; do
# print it
echo $F;
# double-check that it is indeed a directory, and if so
# append its contents to the list for the next level
test -d "$F" && NLIST="$NLIST $(find $F -maxdepth 1 -mindepth 1 -type d)";
done;
# set the current list equal to the next level's list
LIST=$NLIST;
# clear the next level's list
NLIST="";
done
(замените 2 в -lt 2
с глубиной)
По сути, это реализует стандартный алгоритм поиска в ширину, используя $LIST
и $NLIST
как очередь имен каталогов.Вот последний подход в виде однострочника для удобного копирования и вставки:
LIST="$(find . -mindepth 1 -maxdepth 1 -type d)"; let i=0; while test "$i" -lt 2 -a -n "$LIST"; do let i++; for F in $LIST; do echo $F; test -d "$F" && NLIST="$NLIST $(find $F -maxdepth 1 -mindepth 1 -type d)"; done; LIST=$NLIST; NLIST=""; done
Без заслуженного заказа:найти -maxглубина -тип d
Чтобы получить заслуженный порядок, вам придется выполнить рекурсию самостоятельно с помощью этого небольшого шелл-скрипта:
#!/bin/bash
r ()
{
let level=$3+1
if [ $level -gt $4 ]; then return 0; fi
cd "$1"
for d in *; do
if [ -d "$d" ]; then
echo $2/$d
fi;
done
for d in *; do
if [ -d "$d" ]; then
(r "$d" "$2/$d" $level $4)
fi;
done
}
r "$1" "$1" 0 "$2"
Затем вы можете вызвать этот скрипт с параметрами базового каталога и глубины.
Вот возможный способ: использовать find.Я не проверял его полностью, поэтому будьте осторожны...
depth=0
output=$(find . -mindepth $depth -maxdepth $depth -type d | sort);
until [[ ${#output} -eq 0 ]]; do
echo "$output"
let depth=$depth+1
output=$(find . -mindepth $depth -maxdepth $depth -type d | sort)
done
Что-то вроде этого:
find . -type d |
perl -lne'push @_, $_;
print join $/,
sort {
length $a <=> length $b ||
$a cmp $b
} @_ if eof'