Путь

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

Функции в этом модуле могут принимать в качестве аргумента строку или список символов/строку (chardata) и всегда возвращают строку (кодированную в UTF-8).

Большинство функций в этом модуле не взаимодействуют с файловой системой, за исключением нескольких функций, которые требуют этого (например, wildcard/2 и expand/1).

Краткое описание

Типы

t()

Функции

absname(path): Преобразует заданный путь в абсолютный. В отличие от expand/1, попытка разрешить .., . или ~ не предпринимается.
absname(path, relative_to): Создаёт путь от relative_to к path. Если path уже является абсолютным путём, то relative_to игнорируется. См. также relative_to/2
basename(path): Возвращает последнюю компоненту пути или сам путь, если он не содержит разделителей каталогов.
basename(path, extension): Возвращает последнюю компоненту path с удалённым extension. Эта функция должна использоваться для удаления определённого расширения, которое может или не может быть.
dirname(path): Возвращает компонент каталога пути path.
expand(path): Преобразует путь в абсолютный и расширяет символы . и .., а также ведущий ~.
expand(path, relative_to): Расширяет путь относительно пути, заданного как второй аргумент, расширяя символы . и ... Если путь уже является абсолютным, то relative_to игнорируется.
extname(path): Возвращает расширение последней компоненты path.
join(list): Объединяет список путей.
join(left, right): Объединяет два пути.
relative(name): Принудительно задаёт путь как относительный.
relative_to(path, from): Возвращает заданный path относительно заданного from пути. Другими словами, пытается удалить префикс from из path.
relative_to_cwd(path): Удобный способ получить путь относительно текущей рабочей директории. Если по какой-то причине текущая рабочая директория не может быть получена, возвращает полный путь.
rootname(path): Возвращает path с удалённым extension.
rootname(path, extension): Возвращает path с удалённым extension. Эта функция должна использоваться для удаления определённого расширения, которое может или не может быть.
split(path): Разделяет путь на список по разделителю пути.
type(name): Возвращает тип пути.
wildcard(glob, opts \\ []): Перебирает пути в соответствии с заданным выражением glob, и возвращает список совпадений.

Типы

t()

t() :: :unicode.chardata()

Функции

absname(path)

absname(t()) :: binary()

Преобразует заданный путь в абсолютный. В отличие от expand/1, попытка разрешить .., . или ~ не предпринимается.

Примеры Unix

Path.absname("foo")
#=> "/usr/local/foo"

Path.absname("../x")
#=> "/usr/local/../x"

Windows

Path.absname("foo").
"D:/usr/local/foo"
Path.absname("../x").
"D:/usr/local/../x"

absname(path, relative_to)

absname(t(), t()) :: binary()

Создаёт путь от relative_to к path. Если path уже является абсолютным путём, то relative_to игнорируется. См. также relative_to/2.

В отличие от expand/2, попытка разрешить .., . или ~ не предпринимается.

Примеры

iex> Path.absname("foo", "bar")
"bar/foo"

iex> Path.absname("../x", "bar")
"bar/../x"

basename(path)

basename(t()) :: binary()

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

Примеры

iex> Path.basename("foo")
"foo"

iex> Path.basename("foo/bar")
"bar"

iex> Path.basename("/")
""

basename(path, extension)

basename(t(), t()) :: binary()

Возвращает последнюю компоненту path с удалённым extension. Эта функция должна использоваться для удаления определённого расширения, которое может или не может быть.

Примеры

iex> Path.basename("~/foo/bar.ex", ".ex")
"bar"

iex> Path.basename("~/foo/bar.exs", ".ex")
"bar.exs"

iex> Path.basename("~/foo/bar.old.ex", ".ex")
"bar.old"

dirname(path)

dirname(t()) :: binary()

Возвращает компонент каталога path.

Примеры

iex> Path.dirname("/foo/bar.ex")
"/foo"

iex> Path.dirname("/foo/bar/baz.ex")
"/foo/bar"

expand(path)

expand(t()) :: binary()

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

Примеры

Path.expand("/foo/bar/../bar")
#=> "/foo/bar"

expand(path, relative_to)

expand(t(), t()) :: binary()

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

Обратите внимание, что эта функция обрабатывает path с ведущим ~ как абсолютный.

Второй аргумент сначала преобразуется в абсолютный путь.

Примеры

# Assuming that the absolute path to baz is /quux/baz
Path.expand("foo/bar/../bar", "baz")
#=> "/quux/baz/foo/bar"

Path.expand("foo/bar/../bar", "/baz")
"/baz/foo/bar"
Path.expand("/foo/bar/../bar", "/baz")
"/foo/bar"

extname(path)

extname(t()) :: binary()

Возвращает расширение последней компоненты path.

Примеры

iex> Path.extname("foo.erl")
".erl"

iex> Path.extname("~/foo/bar")
""

join(list)

join([t(), ...]) :: binary()

Объединяет список путей.

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

Примеры

iex> Path.join(["~", "foo"])
"~/foo"

iex> Path.join(["foo"])
"foo"

iex> Path.join(["/", "foo", "bar/"])
"/foo/bar"

join(left, right)

join(t(), t()) :: binary()

Объединяет два пути.

Правый путь всегда преобразуется в относительный формат, и любой хвостовой слеш удаляется при объединении.

Примеры

iex> Path.join("foo", "bar")
"foo/bar"

relative(name)

relative(t()) :: binary()

Принудительно задаёт путь как относительный.

Примеры Unix

Path.relative("/usr/local/bin")   #=> "usr/local/bin"
Path.relative("usr/local/bin")    #=> "usr/local/bin"
Path.relative("../usr/local/bin") #=> "../usr/local/bin"

Примеры Windows

Path.relative("D:/usr/local/bin") #=> "usr/local/bin"
Path.relative("usr/local/bin")    #=> "usr/local/bin"
Path.relative("D:bar.ex")         #=> "bar.ex"
Path.relative("/bar/foo.ex")      #=> "bar/foo.ex"

relative_to(path, from)

relative_to(t(), t()) :: binary()

Возвращает заданный path относительно заданного from пути. Другими словами, пытается удалить префикс from из path.

Эта функция не обращается к файловой системе, поэтому предполагает отсутствие символических ссылок между путями.

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

Примеры

iex> Path.relative_to("/usr/local/foo", "/usr/local")
"foo"

iex> Path.relative_to("/usr/local/foo", "/")
"usr/local/foo"

iex> Path.relative_to("/usr/local/foo", "/etc")
"/usr/local/foo"

relative_to_cwd(path)

relative_to_cwd(t()) :: binary()

Удобный способ получить путь относительно текущей рабочей директории. Если по какой-то причине текущая рабочая директория не может быть получена, возвращается полный путь.

rootname(path)

rootname(t()) :: binary()

Возвращает path с удалённым extension.

Примеры

iex> Path.rootname("/foo/bar")
"/foo/bar"

iex> Path.rootname("/foo/bar.ex")
"/foo/bar"

rootname(path, extension)

rootname(t(), t()) :: binary()

Возвращает path с удалённым extension. Эта функция должна использоваться для удаления определённого расширения, которое может или не может быть.

Примеры

iex> Path.rootname("/foo/bar.erl", ".erl")
"/foo/bar"

iex> Path.rootname("/foo/bar.erl", ".ex")
"/foo/bar.erl"

split(path)

split(t()) :: [binary()]

Разделяет путь на список по разделителю пути.

Если в качестве входных данных передана пустая строка, возвращается пустой список.

В Windows пути разбиваются по разделителям «\» и «/», а буква диска, если она есть, всегда возвращается в нижнем регистре.

Примеры

iex> Path.split("")
[]

iex> Path.split("foo")
["foo"]

iex> Path.split("/foo/bar")
["/", "foo", "bar"]

type(name)

type(t()) :: :absolute | :relative | :volumerelative

Возвращает тип пути.

Примеры для Unix

Path.type("/")                #=> :absolute
Path.type("/usr/local/bin")   #=> :absolute
Path.type("usr/local/bin")    #=> :relative
Path.type("../usr/local/bin") #=> :relative
Path.type("~/file")           #=> :relative

Примеры для Windows

Path.type("D:/usr/local/bin") #=> :absolute
Path.type("usr/local/bin")    #=> :relative
Path.type("D:bar.ex")         #=> :volumerelative
Path.type("/bar/foo.ex")      #=> :volumerelative

wildcard(glob, opts \\ [])

wildcard(t(), Keyword.t()) :: [binary()]

Перебирает пути в соответствии с заданным glob выражением и возвращает список совпадений.

Шаблон похож на обычный путь, за исключением того, что некоторые «символы подстановки» интерпретируются особым образом. Следующие символы являются специальными:

? - соответствует одному символу
* - соответствует любому количеству символов до конца имени файла, следующей точки или следующего слэша
** - два последовательных * в качестве одного шаблона будут соответствовать всем файлам и нулю или более каталогам и подкаталогам
[char1,char2,...] - соответствует любому из перечисленных символов; два символа, разделенные дефисом, соответствуют диапазону символов. Не добавляйте пробелы до и после запятой, так как в противном случае она будет соответствовать путям, содержащим сам символ пробела.
{item1,item2,...} - соответствует одному из вариантов. Не добавляйте пробелы до и после запятой, так как в противном случае она будет соответствовать путям, содержащим сам символ пробела.

Другие символы представляют сами себя. Соответствие происходит только в том случае, если пути имеют точно такие же символы в тех же позициях. Обратите внимание, что соответствие чувствительно к регистру; т.е. «a» не будет соответствовать «A».

По умолчанию шаблоны * и ? не соответствуют файлам, начинающимся с точки . , если match_dot: true не указано в opts.

Примеры

Представьте, что у вас есть каталог под названием projects с тремя проектами Elixir внутри: elixir, ex_doc и dynamo. Вы можете найти все .beam файлы внутри каталога ebin каждого проекта следующим образом:

Path.wildcard("projects/*/ebin/**/*.beam")

Если вы хотите искать как .beam , так и .app файлы, вы можете сделать следующее:

Path.wildcard("projects/*/ebin/**/*.{beam,app}")