@spec 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"

@spec 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"

@spec basename(t()) :: binary()

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

Примеры

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

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

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

@spec 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"

@spec dirname(t()) :: binary()

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

Примеры

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

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

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

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

@spec expand(t()) :: binary()

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

Примеры

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

@spec 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"

@spec extname(t()) :: binary()

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

Поведение этой функции изменилось в Erlang/OTP 24 для имён файлов, начинающихся с точки и не имеющих расширения. Например, для файла с именем ".gitignore", extname/1 теперь возвращает пустую строку, тогда как в предыдущих версиях Erlang/OTP возвращалось ".gitignore". Это было сделано для соответствия поведению rootname/1, которое возвращало ".gitignore" в качестве имени (и поэтому оно также не может быть расширением).

См. basename/1 и rootname/1 для связанных функций извлечения информации из путей.

Примеры

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

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

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

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

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

Примеры

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

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

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

@spec join(t(), t()) :: binary()

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

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

Примеры

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

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

Функции в этом модуле поддерживают chardata, поэтому передача списка будет обрабатывать его как единое целое:

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

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

@spec 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"

@spec 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"

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

@spec relative_to_cwd(t()) :: binary()

Удобный способ получить путь, относительный к текущей рабочей директории.

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

@spec rootname(t()) :: binary()

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

Примеры

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

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

@spec 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"

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

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

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

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

Примеры

iex> Path.split("")
[]

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

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

@spec 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

@spec wildcard(
  t(),
  keyword()
) :: [binary()]

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

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

• ? - соответствует одному символу.

• * - соответствует любому количеству символов до конца имени файла, следующей точки или следующего слэша.

• ** - два смежных символа * в качестве одного шаблона будут соответствовать всем файлам и нулю или более каталогам и подкаталогам.

• [char1,char2,...] - соответствует любому из перечисленных символов; два символа, разделенные дефисом, будут соответствовать диапазону символов. Не добавляйте пробелы до и после запятой, так как в противном случае это будет соответствовать путям, содержащим сам символ пробела.

• {item1,item2,...} - соответствует одному из альтернатив. Не добавляйте пробелы до и после запятой, так как в противном случае это будет соответствовать путям, содержащим сам символ пробела.

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

Разделители каталогов всегда должны быть записаны как /, даже в Windows. Вы можете вызвать Path.expand/1 для нормализации пути перед вызовом этой функции.

По умолчанию шаблоны * и ? не соответствуют файлам, начинающимся с точки .. См. опцию :match_dot в разделе «Параметры» ниже.

Параметры

• :match_dot - (boolean) если false, специальные символы подстановки * и ? не будут соответствовать файлам, начинающимся с точки (.). Если true, файлы, начинающиеся с . не будут обрабатываться специально. По умолчанию false.

Примеры

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

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

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

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