このページの英語版を見る

std.path

このモジュールはパス文字列の操作に使用される。

すべての関数(ただし、 expandTilde(および一部の場合を除き absolutePathおよび relativePath)は、純粋な文字列操作関数であり、プログラム外の状態に依存せず、実際のファイルシステム操作も行わない。このため、このモジュールでは、ディレクトリを指すパスとファイルを指すパスの区別をせず、パスが指すオブジェクトが実際にファイルシステム上に存在するかどうかを認識しない。これらのケースを区別するには、 std.file.isDirと std.file.exists。

Windowsでは、バックスラッシュ(\) とスラッシュ (/原則として有効なディレクトリ区切り文字である。このモジュールでは、両者を同等に扱うが、新しい区切り文字が追加された場合は、バックスラッシュが使用される。さらに、 buildNormalizedPath そのプラットフォーム上では、すべてのスラッシュがバックスラッシュに置き換えられる。

一般的に、このモジュールの関数は、入力パスが整形式であると仮定しています。(つまり、無効な文字を含んではならず、ファイルシステムのパス形式に従う必要があります。) 無効なパスで関数を呼び出した場合の結果は未定義です。パスやファイル名が無効である可能性がある場合(例えば、ユーザーが入力した場合など)、 isValidFilenameおよび isValidPath関数を使用して確認することが望ましい場合がある。

ほとんどの関数はメモリ割り当てを行わず、文字列が返される場合は、通常は入力文字列のスライスである。関数でメモリ割り当てが行われる場合は、ドキュメントにその旨が明示的に記載されている。


カテゴリー	関数
正規化	absolutePath asAbsolutePath asNormalizedPath asRelativePath buildNormalizedPath buildPath chainPath expandTilde
パーティショニング	baseName dirName dirSeparator driveName pathSeparator pathSplitter relativePath rootName stripDrive
バリデーション	isAbsolute isDirSeparator isRooted isValidFilename isValidPath
拡張	defaultExtension extension setExtension stripExtension withDefaultExtension withExtension
その他	filenameCharCmp filenameCmp globMatch CaseSensitive

Authors:

Lars Tandle Kyllingstad, Walter Bright, Grzegorz Adam Hankiewicz, Thomas Kühne, Andrei Alexandrescu

License:

Boost License 1.0

ソースstd/path.d

enum string dirSeparator;

パス内のディレクトリ名を区切るために使用される文字列。 POSIXではスラッシュ、Windowsではバックスラッシュである。

enum string pathSeparator;

パス区切り文字列。POSIXではコロン、Windowsではセミコロンである。

pure nothrow @nogc @safe bool isDirSeparator(dchar c);

指定された文字がディレクトリセパレータであるかどうかを決定する。

Windowsでは、これには \。 /。 POSIXでは、それはただの /。

to include both両方とも含む

Examples:

version (Windows)
{
    assert( '/'.isDirSeparator);
    assert( '\\'.isDirSeparator);
}
else
{
    assert( '/'.isDirSeparator);
    assert(!'\\'.isDirSeparator);
}

enum CaseSensitive: bool;

このenum は、ファイル名を比較する関数のテンプレート引数として使用され、比較が大文字と小文字を区別するかどうかを決定する。

to compare比較する

Examples:

writeln(baseName!(CaseSensitive.no)("dir/file.EXT", ".ext")); // "file"
assert(baseName!(CaseSensitive.yes)("dir/file.EXT", ".ext") != "file");

version (Posix)
    writeln(relativePath!(CaseSensitive.no)("/FOO/bar", "/foo/baz")); // "../bar"
else
    writeln(relativePath!(CaseSensitive.no)(`c:\FOO\bar`, `c:\foo\baz`)); // `..\bar`

no: ファイル名の大文字と小文字は区別されない
yes: ファイル名の大文字と小文字は区別される
osDefault: 現在のプラットフォームのデフォルト(または最も一般的な)設定。つまり、WindowsとMac OS Xではno 、 Darwin(Linux、*BSDなど)以外のすべてのPOSIXシステムではyes となる。

auto baseName(R)(return scope R path) if (isRandomAccessRange!R && hasSlicing!R && isSomeChar!(ElementType!R) && !isSomeString!R); auto baseName(C)(return scope C[] path) if (isSomeChar!C); pure @safe inout(C)[] baseName(CaseSensitive cs = CaseSensitive.osDefault, C, C1)(return scope inout(C)[] path, in C1[] suffix) if (isSomeChar!C && isSomeChar!C1);

Parameters:

cs	接尾辞の一致が大文字と小文字を区別するかどうか。
R `path`	パス名。文字列、またはランダムアクセス可能な文字の範囲である。
C1[] `suffix`	ファイル名から削除するオプションの接尾辞。

Returns:

パス名内のファイル名。先頭のディレクトリを除き、任意の接尾辞を削除したもの。

が指定された場合、 suffixが指定された場合、xml-ph-0000@deepl.internal を使用して比較されます。 path filenameCmp!cs を使用して比較され、cs は比較を大文字と小文字を区別するかどうかを決定するオプションのテンプレートパラメータである。詳細は filenameCmp詳細はドキュメントを参照のこと。

注釈この関数は、指定されたサフィックスのみを削除する。必ずしも拡張子を表す必要はない。パスから拡張子を削除するには、拡張子が何であるかに関係なく、 stripExtension。ディレクトリ名や拡張子を除いたファイル名を取得するには、次のように関数を組み合わせる。

assert(baseName(stripExtension("dir/file.ext")) == "file");

toto

Standards: この関数は、POSIXの「basename」シェルユーティリティ要件に準拠している(Windowsパスに適した修正を加えている)。

この関数は、 POSIXの「basename」シェルユーティリティ要件に準拠している (Windowsパス用に適宜修正)。

POSIXPOSIX

Examples:

writeln(baseName("dir/file.ext")); // "file.ext"
writeln(baseName("dir/file.ext", ".ext")); // "file"
writeln(baseName("dir/file.ext", ".xyz")); // "file.ext"
writeln(baseName("dir/filename", "name")); // "file"
writeln(baseName("dir/subdir/")); // "subdir"

version (Windows)
{
    writeln(baseName(`d:file.ext`)); // "file.ext"
    writeln(baseName(`d:\dir\file.ext`)); // "file.ext"
}

auto dirName(R)(return scope R path) if (isRandomAccessRange!R && hasSlicing!R && hasLength!R && isSomeChar!(ElementType!R) && !isSomeString!R); auto dirName(C)(return scope C[] path) if (isSomeChar!C);

親ディレクトリを返す path。Windowsでは、ドライブ文字が存在する場合はこれも含む。 path相対パスであり、親ディレクトリが現在の作業ディレクトリである場合は、"." を返します。

Parameters:

R path パス名。

Returns:

またはxml-ph-0000@deepl.internal。 pathまたは"." 。

Standards: この機能は、POSIXの要件を満たすシェルユーティリティ「dirname」に(Windowsのパスに適応した形で)準拠している。

この関数は、 POSIXの要件を満たすシェルユーティリティ「dirname」に準拠している(Windowsのパスに適応したもの)。

Examples:

writeln(dirName("")); // "."
writeln(dirName("file"w)); // "."
writeln(dirName("dir/"d)); // "."
writeln(dirName("dir///")); // "."
writeln(dirName("dir/file"w.dup)); // "dir"
writeln(dirName("dir///file"d.dup)); // "dir"
writeln(dirName("dir/subdir/")); // "dir"
writeln(dirName("/dir/file"w)); // "/dir"
writeln(dirName("/file"d)); // "/"
writeln(dirName("/")); // "/"
writeln(dirName("///")); // "/"

version (Windows)
{
    writeln(dirName(`dir\`)); // `.`
    writeln(dirName(`dir\\\`)); // `.`
    writeln(dirName(`dir\file`)); // `dir`
    writeln(dirName(`dir\\\file`)); // `dir`
    writeln(dirName(`dir\subdir\`)); // `dir`
    writeln(dirName(`\dir\file`)); // `\dir`
    writeln(dirName(`\file`)); // `\`
    writeln(dirName(`\`)); // `\`
    writeln(dirName(`\\\`)); // `\`
    writeln(dirName(`d:`)); // `d:`
    writeln(dirName(`d:file`)); // `d:`
    writeln(dirName(`d:\`)); // `d:\`
    writeln(dirName(`d:\file`)); // `d:\`
    writeln(dirName(`d:\dir\file`)); // `d:\dir`
    writeln(dirName(`\\server\share\dir\file`)); // `\\server\share\dir`
    writeln(dirName(`\\server\share\file`)); // `\\server\share`
    writeln(dirName(`\\server\share\`)); // `\\server\share`
    writeln(dirName(`\\server\share`)); // `\\server\share`
}

auto rootName(R)(R path) if (isRandomAccessRange!R && hasSlicing!R && hasLength!R && isSomeChar!(ElementType!R) && !isSomeString!R); auto rootName(C)(C[] path) if (isSomeChar!C);

指定されたパスのルートディレクトリを返す。または、パスがルート化されていない場合はnull を返す。

Parameters: パス名。

R path パス名。

Returns: スライス

スライス path。

path nameパス名

Examples:

assert(rootName("") is null);
assert(rootName("foo") is null);
writeln(rootName("/")); // "/"
writeln(rootName("/foo/bar")); // "/"

version (Windows)
{
    assert(rootName("d:foo") is null);
    writeln(rootName(`d:\foo`)); // `d:\`
    writeln(rootName(`\\server\share\foo`)); // `\\server\share`
    writeln(rootName(`\\server\share`)); // `\\server\share`
}

sliceドライブ部分ドライブ部分を取得する。

auto driveName(R)(R path) if (isRandomAccessRange!R && hasSlicing!R && hasLength!R && isSomeChar!(ElementType!R) && !isSomeString!R); auto driveName(C)(C[] path) if (isSomeChar!C);

パスのドライブ部分を取得する。

Parameters:

R path 文字列または文字の範囲を

Returns:

ドライブの部分 pathドライブ、またはドライブが指定されていない場合は空の範囲。 UNC パスが指定されている場合は、ネットワーク共有が返される。

POSIX では、常に空の範囲が返される。

drivePOSIX

Examples:

import std.range : empty;
version (Posix)  assert(driveName("c:/foo").empty);
version (Windows)
{
    assert(driveName(`dir\file`).empty);
    writeln(driveName(`d:file`)); // "d:"
    writeln(driveName(`d:\file`)); // "d:"
    writeln(driveName("d:")); // "d:"
    writeln(driveName(`\\server\share\file`)); // `\\server\share`
    writeln(driveName(`\\server\share\`)); // `\\server\share`
    writeln(driveName(`\\server\share`)); // `\\server\share`

    static assert(driveName(`d:\file`) == "d:");
}

auto stripDrive(R)(R path) if (isRandomAccessRange!R && hasSlicing!R && isSomeChar!(ElementType!R) && !isSomeString!R); auto stripDrive(C)(C[] path) if (isSomeChar!C);

Windows パスからドライブ名を削除する。 POSIX では、パスは変更されずに

Parameters:

R path パス名

Returns: ドライブコンポーネントを除いたパスの一部。

ドライブコンポーネントを除いたパスの一部。

pathnameパス名

Examples:

version (Windows)
{
    writeln(stripDrive(`d:\dir\file`)); // `\dir\file`
    writeln(stripDrive(`\\server\share\dir\file`)); // `\dir\file`
}

auto extension(R)(R path) if (isRandomAccessRange!R && hasSlicing!R && isSomeChar!(ElementType!R) || is(StringTypeOf!R));

Parameters:

R path パス名。

Returns: ファイル名の拡張子部分(ピリオドも含む)。xml-ph-0000@deepl.internal 拡張子がない場合は、xml-ph-0001@deepl.internalとなる。

ファイル名の拡張子部分(ピリオドも含む)。

拡張子が存在しない場合は、null が返される。

emailemail

Examples:

import std.range : empty;
assert(extension("file").empty);
writeln(extension("file.")); // "."
writeln(extension("file.ext"w)); // ".ext"
writeln(extension("file.ext1.ext2"d)); // ".ext2"
assert(extension(".foo".dup).empty);
writeln(extension(".foo.ext"w.dup)); // ".ext"

static assert(extension("file").empty);
static assert(extension("file.ext") == ".ext");

auto stripExtension(R)(R path) if (isRandomAccessRange!R && hasSlicing!R && hasLength!R && isSomeChar!(ElementType!R) && !isSomeString!R); auto stripExtension(C)(C[] path) if (isSomeChar!C);

パスから拡張子を削除する。

Parameters:

R path 文字列または範囲を切り取る

Returns: 拡張子(もしあれば)を削除したパスを切り取る

拡張子(もしあれば)を削除したパスをスライスする

rangerange

Examples:

writeln(stripExtension("file")); // "file"
writeln(stripExtension("file.ext")); // "file"
writeln(stripExtension("file.ext1.ext2")); // "file.ext1"
writeln(stripExtension("file.")); // "file"
writeln(stripExtension(".file")); // ".file"
writeln(stripExtension(".file.ext")); // ".file"
writeln(stripExtension("dir/file.ext")); // "dir/file"

immutable(C1)[] setExtension(C1, C2)(in C1[] path, in C2[] ext) if (isSomeChar!C1 && !is(C1 == immutable) && is(immutable(C1) == immutable(C2))); immutable(C1)[] setExtension(C1, C2)(immutable(C1)[] path, const(C2)[] ext) if (isSomeChar!C1 && is(immutable(C1) == immutable(C2)));

拡張子を設定または置き換える。

ファイル名にすでに拡張子がある場合は、置き換えられる。ない場合は、拡張子が単にファイル名に追加される。先頭のドットを含めるかどうかは任意である。 extことは任意である。

拡張子が空の場合、この関数は stripExtension。

この関数は通常、新しい文字列を割り当てる(例外として、パスが変更不可で、すでに拡張子がない場合がある )。

Parameters:

C1[] `path`	パス名
C2[] `ext`	新しい拡張子

Returns:

で指定されたパスを含む文字列。 path、拡張子は設定されている。 ext。

See Also:

withExtensionこれは、遅延範囲を割り当てずに返す。

lazy range遅延範囲

Examples:

writeln(setExtension("file", "ext")); // "file.ext"
writeln(setExtension("file"w, ".ext"w)); // "file.ext"
writeln(setExtension("file."d, "ext"d)); // "file.ext"
writeln(setExtension("file.", ".ext")); // "file.ext"
writeln(setExtension("file.old"w, "new"w)); // "file.new"
writeln(setExtension("file.old"d, ".new"d)); // "file.new"

ファイル指定の既存の拡張子を新しいものに置き換える。

auto withExtension(R, C)(R path, C[] ext) if (isRandomAccessRange!R && hasSlicing!R && hasLength!R && isSomeChar!(ElementType!R) && !isSomeString!R && isSomeChar!C); auto withExtension(C1, C2)(C1[] path, C2[] ext) if (isSomeChar!C1 && isSomeChar!C2);

ファイル指定の既存の拡張子を新しいものに置き換える。

Parameters:

R `path`	ファイル名を表す文字列またはランダムアクセス可能な範囲
C[] `ext`	新しい拡張子

Returns:

Range の path(もしあれば)拡張子は置き換えられる。 ext。返された範囲の要素のエンコード型は、 path。

rangerange

See Also:

setExtension

rangerange

Examples:

import std.array;
writeln(withExtension("file", "ext").array); // "file.ext"
writeln(withExtension("file"w, ".ext"w).array); // "file.ext"
writeln(withExtension("file.ext"w, ".").array); // "file."

import std.utf : byChar, byWchar;
writeln(withExtension("file".byChar, "ext").array); // "file.ext"
writeln(withExtension("file"w.byWchar, ".ext"w).array); // "file.ext"w
writeln(withExtension("file.ext"w.byWchar, ".").array); // "file."w

immutable(C1)[] defaultExtension(C1, C2)(in C1[] path, in C2[] ext) if (isSomeChar!C1 && is(immutable(C1) == immutable(C2)));

Parameters: パス名。

C1[] `path`	パス名。
C2[] `ext`	デフォルトで使用する拡張子。

Returns:

で指定されたパス、 path、拡張子は ext パスに拡張子がすでに含まれていない場合は、拡張子が追加される。

拡張子にドットを含めるかどうかは任意である。

この関数は、パスが変更不可で拡張子をすでに持っている場合を除き、常に新しい文字列を割り当てる。

extensionextension

Examples:

writeln(defaultExtension("file", "ext")); // "file.ext"
writeln(defaultExtension("file", ".ext")); // "file.ext"
writeln(defaultExtension("file.", "ext")); // "file."
writeln(defaultExtension("file.old", "new")); // "file.old"
writeln(defaultExtension("file.old", ".new")); // "file.old"

auto withDefaultExtension(R, C)(R path, C[] ext) if (isRandomAccessRange!R && hasSlicing!R && hasLength!R && isSomeChar!(ElementType!R) && !isSomeString!R && isSomeChar!C); auto withDefaultExtension(C1, C2)(C1[] path, C2[] ext) if (isSomeChar!C1 && isSomeChar!C2);

拡張子を path。 extpathない場合は、

Parameters:

R `path`	ファイル名を文字列または範囲として
C[] `ext`	拡張子、先頭に「.」がある場合がある

Returns: 範囲が結果に含まれる可能性がある。

結果の範囲

rangerange

Examples:

import std.array;
writeln(withDefaultExtension("file", "ext").array); // "file.ext"
writeln(withDefaultExtension("file"w, ".ext").array); // "file.ext"w
writeln(withDefaultExtension("file.", "ext").array); // "file."
writeln(withDefaultExtension("file", "").array); // "file."

import std.utf : byChar, byWchar;
writeln(withDefaultExtension("file".byChar, "ext").array); // "file.ext"
writeln(withDefaultExtension("file"w.byWchar, ".ext").array); // "file.ext"w
writeln(withDefaultExtension("file.".byChar, "ext"d).array); // "file."
writeln(withDefaultExtension("file".byChar, "").array); // "file."

immutable(ElementEncodingType!(ElementType!Range))[] buildPath(Range)(scope Range segments) if (isInputRange!Range && !isInfinite!Range && isSomeString!(ElementType!Range)); pure nothrow @safe immutable(C)[] buildPath(C)(const(C)[][] paths...) if (isSomeChar!C);

1つ以上のパスセグメントを結合する。

この関数は、文字列要素の入力範囲として、または文字列引数のセットとして指定されたパスセグメントのセットを受け取り、それらを連結する。必要に応じて、ディレクトリセパレータがセグメント間に挿入される。パスセグメントのいずれかが絶対パス( isAbsolute)、先行するセグメントは削除される。

Windows では、パスのセグメントの1つがルート化されているが絶対パスではない場合 (例えば \foo、前のルートまでのすべてのパスセグメントが削除される。 (例については下記を参照のこと。)

この関数は、常に結果のパスを保持するためのメモリを割り当てる。可変長引数オーバーロードは、単一の割り当てのみを実行することが保証されている。範囲バージョンも同様である。 paths順方向範囲である

Parameters:

Range segments 入力範囲のセグメントからパスを組み立てる。

Returns: 組み立てられたパス。

組み立てられたパス。

range範囲

Examples:

version (Posix)
{
    writeln(buildPath("foo", "bar", "baz")); // "foo/bar/baz"
    writeln(buildPath("/foo/", "bar/baz")); // "/foo/bar/baz"
    writeln(buildPath("/foo", "/bar")); // "/bar"
}

version (Windows)
{
    writeln(buildPath("foo", "bar", "baz")); // `foo\bar\baz`
    writeln(buildPath(`c:\foo`, `bar\baz`)); // `c:\foo\bar\baz`
    writeln(buildPath("foo", `d:\bar`)); // `d:\bar`
    writeln(buildPath("foo", `\bar`)); // `\bar`
    writeln(buildPath(`c:\foo`, `\bar`)); // `c:\bar`
}

auto chainPath(R1, R2, Ranges...)(R1 r1, R2 r2, Ranges ranges) if ((isRandomAccessRange!R1 && hasSlicing!R1 && hasLength!R1 && isSomeChar!(ElementType!R1) || isNarrowString!R1 && !isConvertibleToString!R1) && (isRandomAccessRange!R2 && hasSlicing!R2 && hasLength!R2 && isSomeChar!(ElementType!R2) || isNarrowString!R2 && !isConvertibleToString!R2) && (Ranges.length == 0 || is(typeof(chainPath(r2, ranges)))));

複数のパスセグメントを結合して1つのパスを形成する。

Parameters: 最初のセグメント

R1 `r1`	最初のセグメント
R2 `r2`	2番目のセグメント
Ranges `ranges`	0個以上のセグメント

Returns: r1、r2、およびパス区切り文字を持つ範囲の連結である、遅延範囲。結果として得られる要素タイプはr1のタイプとなる。

r1、r2、およびパス区切り文字を持つ範囲の連結である、遅延範囲。結果として得られる要素の型はr1の型となる。

See Also:

buildPath

segmentsegment

Examples:

import std.array;
version (Posix)
{
    writeln(chainPath("foo", "bar", "baz").array); // "foo/bar/baz"
    writeln(chainPath("/foo/", "bar/baz").array); // "/foo/bar/baz"
    writeln(chainPath("/foo", "/bar").array); // "/bar"
}

version (Windows)
{
    writeln(chainPath("foo", "bar", "baz").array); // `foo\bar\baz`
    writeln(chainPath(`c:\foo`, `bar\baz`).array); // `c:\foo\bar\baz`
    writeln(chainPath("foo", `d:\bar`).array); // `d:\bar`
    writeln(chainPath("foo", `\bar`).array); // `\bar`
    writeln(chainPath(`c:\foo`, `\bar`).array); // `c:\bar`
}

import std.utf : byChar;
version (Posix)
{
    writeln(chainPath("foo", "bar", "baz").array); // "foo/bar/baz"
    writeln(chainPath("/foo/".byChar, "bar/baz").array); // "/foo/bar/baz"
    writeln(chainPath("/foo", "/bar".byChar).array); // "/bar"
}

version (Windows)
{
    writeln(chainPath("foo", "bar", "baz").array); // `foo\bar\baz`
    writeln(chainPath(`c:\foo`.byChar, `bar\baz`).array); // `c:\foo\bar\baz`
    writeln(chainPath("foo", `d:\bar`).array); // `d:\bar`
    writeln(chainPath("foo", `\bar`.byChar).array); // `\bar`
    writeln(chainPath(`c:\foo`, `\bar`w).array); // `c:\bar`
}

pure nothrow @safe immutable(C)[] buildNormalizedPath(C)(const(C[])[] paths...) if (isSomeChar!C);

と同じタスクを実行するが、 buildPath。同時に、カレントディレクトリ/親ディレクトリシンボル("." および".." )を解決し、余分なディレクトリセパレータを削除する。パスが開始ディレクトリを指している場合は「.」を返す。 Windowsでは、スラッシュはバックスラッシュに置き換えられる。

nullパスに対してbuildNormalizedPathを使用すると、常にnullが返される。

この関数はシンボリックリンクを解決しないことに注意。

この関数は、常に結果のパスを保持するためのメモリを割り当てる。 asNormalizedPathメモリを割り当てないようにするには

Parameters:

const(C[])[] paths 結合するパスの配列。

Returns:

組み立てられたパス。

pathpath

Examples:

writeln(buildNormalizedPath("foo", "..")); // "."

version (Posix)
{
    writeln(buildNormalizedPath("/foo/./bar/..//baz/")); // "/foo/baz"
    writeln(buildNormalizedPath("../foo/.")); // "../foo"
    writeln(buildNormalizedPath("/foo", "bar/baz/")); // "/foo/bar/baz"
    writeln(buildNormalizedPath("/foo", "/bar/..", "baz")); // "/baz"
    writeln(buildNormalizedPath("foo/./bar", "../../", "../baz")); // "../baz"
    writeln(buildNormalizedPath("/foo/./bar", "../../baz")); // "/baz"
}

version (Windows)
{
    writeln(buildNormalizedPath(`c:\foo\.\bar/..\\baz\`)); // `c:\foo\baz`
    writeln(buildNormalizedPath(`..\foo\.`)); // `..\foo`
    writeln(buildNormalizedPath(`c:\foo`, `bar\baz\`)); // `c:\foo\bar\baz`
    writeln(buildNormalizedPath(`c:\foo`, `bar/..`)); // `c:\foo`
    assert(buildNormalizedPath(`\\server\share\foo`, `..\bar`) ==
            `\\server\share\bar`);
}

auto asNormalizedPath(R)(return scope R path) if (isSomeChar!(ElementEncodingType!R) && (isRandomAccessRange!R && hasSlicing!R && hasLength!R || isNarrowString!R) && !isConvertibleToString!R);

カレントディレクトリ/親ディレクトリシンボル("." および".." )を解消し、余分なディレクトリセパレータを削除することでパスを正規化する。パスが開始ディレクトリを指している場合は「.」を返す。 Windowsでは、スラッシュはバックスラッシュに置き換えられる。

asNormalizedPathを空のパスで使用すると、常に空のパスが返される。

シンボリックリンクは解決しない。

この関数は、常に結果のパスを保持するためのメモリを割り当てる。 buildNormalizedPathメモリを割り当て、文字列を返す。

Parameters: 文字列またはランダムアクセス可能な範囲で正規化するパスを表す

R path 正規化するパスを表す文字列またはランダムアクセス可能な範囲

Returns: 正規化されたパスを前方参照として

正規化されたパスを前方参照として

rangerange

Examples:

import std.array;
writeln(asNormalizedPath("foo/..").array); // "."

version (Posix)
{
    writeln(asNormalizedPath("/foo/./bar/..//baz/").array); // "/foo/baz"
    writeln(asNormalizedPath("../foo/.").array); // "../foo"
    writeln(asNormalizedPath("/foo/bar/baz/").array); // "/foo/bar/baz"
    writeln(asNormalizedPath("/foo/./bar/../../baz").array); // "/baz"
}

version (Windows)
{
    writeln(asNormalizedPath(`c:\foo\.\bar/..\\baz\`).array); // `c:\foo\baz`
    writeln(asNormalizedPath(`..\foo\.`).array); // `..\foo`
    writeln(asNormalizedPath(`c:\foo\bar\baz\`).array); // `c:\foo\bar\baz`
    writeln(asNormalizedPath(`c:\foo\bar/..`).array); // `c:\foo`
    assert(asNormalizedPath(`\\server\share\foo\..\bar`).array ==
            `\\server\share\bar`);
}

auto pathSplitter(R)(R path) if ((isRandomAccessRange!R && hasSlicing!R || isNarrowString!R) && !isConvertibleToString!R);

パスを要素に分割する。

Parameters: 文字列またはスライス可能なランダムアクセス範囲

R path 文字列またはスライス可能なランダムアクセス範囲

Returns: 双方向のスライス範囲

双方向のスライス範囲の path

range範囲

Examples:

import std.algorithm.comparison : equal;
import std.conv : to;

assert(equal(pathSplitter("/"), ["/"]));
assert(equal(pathSplitter("/foo/bar"), ["/", "foo", "bar"]));
assert(equal(pathSplitter("foo/../bar//./"), ["foo", "..", "bar", "."]));

version (Posix)
{
    assert(equal(pathSplitter("//foo/bar"), ["/", "foo", "bar"]));
}

version (Windows)
{
    assert(equal(pathSplitter(`foo\..\bar\/.\`), ["foo", "..", "bar", "."]));
    assert(equal(pathSplitter("c:"), ["c:"]));
    assert(equal(pathSplitter(`c:\foo\bar`), [`c:\`, "foo", "bar"]));
    assert(equal(pathSplitter(`c:foo\bar`), ["c:foo", "bar"]));
}

random access rangeパス

bool isRooted(R)(R path) if (isRandomAccessRange!R && isSomeChar!(ElementType!R) || is(StringTypeOf!R));

パスがルートディレクトリから始まるかどうかを決定する。

Parameters:

R path パス名。

Returns: パスがルートディレクトリから始まっているかどうか。xml-ph-0000@deepl.internal POSIXでは、この関数は、パスがスラッシュ(/)で始まっている場合にのみ真を返す。

パスがルートディレクトリから始まっているかどうか。

POSIXでは、この関数は、パスがスラッシュ(/)で始まっている場合にのみ trueを返す。

Windowsでは、この関数は、パスが現在のドライブ、他のドライブ、またはネットワークドライブのルートディレクトリから始まっている場合に trueを返す。

truetrue

Examples:

version (Posix)
{
    assert( isRooted("/"));
    assert( isRooted("/foo"));
    assert(!isRooted("foo"));
    assert(!isRooted("../foo"));
}

version (Windows)
{
    assert( isRooted(`\`));
    assert( isRooted(`\foo`));
    assert( isRooted(`d:\foo`));
    assert( isRooted(`\\foo\bar`));
    assert(!isRooted("foo"));
    assert(!isRooted("d:foo"));
}

pure nothrow @safe bool isAbsolute(R)(R path) if (isRandomAccessRange!R && isSomeChar!(ElementType!R) || is(StringTypeOf!R));

パスが絶対パスであるかどうかを判断する。

Parameters:

R path パス名。

Returns:

パスが絶対パスであるか否かを指定する。

例 POSIXでは、絶対パスはルートディレクトリから始まる。 (実際には、_isAbsolute は単なるエイリアスである。 isRooted。

version (Posix)
{
    assert(isAbsolute("/"));
    assert(isAbsolute("/foo"));
    assert(!isAbsolute("foo"));
    assert(!isAbsolute("../foo"));
}

Windowsでは、絶対パスは特定のドライブのルートディレクトリから始まる。したがって、それは d:\または d:/、ここでd はドライブ文字である。あるいは、ネットワークパス、すなわち、2つの(バックスラッシュ)で始まるパスでもよい。

version (Windows)
{
    assert(isAbsolute(`d:\`));
    assert(isAbsolute(`d:\foo`));
    assert(isAbsolute(`\\foo\bar`));
    assert(!isAbsolute(`\`));
    assert(!isAbsolute(`\foo`));
    assert(!isAbsolute("d:foo"));
}

pure @safe string absolutePath(return scope const string path, lazy string base = getcwd());

path絶対パスに変換する。

次のアルゴリズムが使用される。

が空の場合、xml-ph-0000@deepl.internal を返す。 path空の場合は、null を返す。
すでに絶対パスである場合は、それを返す。 pathすでに絶対パスである場合は、それを返す。
それ以外の場合、 pathに追加し baseし、結果を返す。もし base指定されていない場合は、現在の作業ディレクトリが使用される。

この関数は、このアルゴリズムの第3段階に到達した場合にのみメモリを割り当てる。

注釈: absolutePath.. セグメントを正規化しないことに注意。 buildNormalizedPath(absolutePath(path))必要であれば

xml-ph-0000@deepl.internalxml-ph-0000@deepl.internal

Parameters: 変換する相対パス

string `path`	変換する相対パス
string `base`	相対パスのベースディレクトリを変更する

Returns: 変換されたパスの文字列

変換されたパスの文字列

Throws:

Exception 指定されたベースディレクトリが絶対パスでない場合。

stringstring

See Also:

asAbsolutePath割り当てられていない

to allocate割り当てる

Examples:

version (Posix)
{
    writeln(absolutePath("some/file", "/foo/bar")); // "/foo/bar/some/file"
    writeln(absolutePath("../file", "/foo/bar")); // "/foo/bar/../file"
    writeln(absolutePath("/some/file", "/foo/bar")); // "/some/file"
}

version (Windows)
{
    writeln(absolutePath(`some\file`, `c:\foo\bar`)); // `c:\foo\bar\some\file`
    writeln(absolutePath(`..\file`, `c:\foo\bar`)); // `c:\foo\bar\..\file`
    writeln(absolutePath(`c:\some\file`, `c:\foo\bar`)); // `c:\some\file`
    writeln(absolutePath(`\`, `c:\`)); // `c:\`
    writeln(absolutePath(`\some\file`, `c:\foo\bar`)); // `c:\some\file`
}

変換する

auto asAbsolutePath(R)(R path) if ((isRandomAccessRange!R && isSomeChar!(ElementType!R) || isNarrowString!R) && !isConvertibleToString!R);

変換して path絶対パスに変換する。

以下のアルゴリズムが使用される。

が空の場合、xml-ph-0000@deepl.internal を返す。 pathが空の場合、null を返す。
すでに絶対パスである場合は、それを返す。 pathすでに絶対パスである場合は、それを返す。
それ以外の場合、 path現在の作業ディレクトリに追加し、メモリを割り当てる。

xml-ph-0000@deepl.internalセグメントは正規化されないことに注意。 asAbsolutePath.. セグメントを正規化しないことに注意。 asNormalizedPath(asAbsolutePath(path))必要であれば、

Parameters:

R path 変換する相対パス

Returns: 変換されたパスを遅延範囲として

変換されたパスを遅延範囲として

See Also:

absolutePathこれは、割り当てられた文字列を返す

rangerange

Examples:

import std.array;
writeln(asAbsolutePath(cast(string)null).array); // ""
version (Posix)
{
    writeln(asAbsolutePath("/foo").array); // "/foo"
}
version (Windows)
{
    writeln(asAbsolutePath("c:/foo").array); // "c:/foo"
}
asAbsolutePath("foo");

string relativePath(CaseSensitive cs = CaseSensitive.osDefault)(string path, lazy string base = getcwd());

path相対パスに変換する。

返されるパスは、 base、デフォルトでは現在の作業ディレクトリとみなされる。指定する場合は、 base絶対パスでなければならず、常にディレクトリを参照しているものと見なされます。 pathおよび base同じディレクトリを参照している場合、関数は .。

次のアルゴリズムが使用される。

相対ディレクトリであれば、そのまま返す。 path相対ディレクトリの場合は、そのまま返す。
と共通のルートを見つけ、 path。 base。共通のルートがない場合は、 pathそのまま返す。
できるだけ多くの文字列を準備する ../または ..\ベースパスから共通ルートに到達するために必要なだけ
残りのセグメントを path文字列に追加し、戻り値を返す。

2番目のステップでは、パスコンポーネントがfilenameCmp!cs を使用して比較される。ここで、cs はオプションのテンプレートパラメータであり、比較が大文字と小文字を区別するかどうかを決定する。詳細は filenameCmp。

この関数はメモリを割り当てる。

Parameters:

cs	ベースパスに対してパス名のコンポーネントを照合する際に大文字と小文字を区別すべきかどうか。
string `path`	パス名。
string `base`	相対パスを構築するためのベースパス。

Returns: 相対パス。

相対パス。

See Also: メモリを割り当てない

asRelativePathメモリを割り当てない

Throws:

Exception 指定されたベースディレクトリが絶対パスでない場合は、メモリを割り当てない。

whichだ

Examples:

writeln(relativePath("foo")); // "foo"

version (Posix)
{
    writeln(relativePath("foo", "/bar")); // "foo"
    writeln(relativePath("/foo/bar", "/foo/bar")); // "."
    writeln(relativePath("/foo/bar", "/foo/baz")); // "../bar"
    writeln(relativePath("/foo/bar/baz", "/foo/woo/wee")); // "../../bar/baz"
    writeln(relativePath("/foo/bar/baz", "/foo/bar")); // "baz"
}
version (Windows)
{
    writeln(relativePath("foo", `c:\bar`)); // "foo"
    writeln(relativePath(`c:\foo\bar`, `c:\foo\bar`)); // "."
    writeln(relativePath(`c:\foo\bar`, `c:\foo\baz`)); // `..\bar`
    writeln(relativePath(`c:\foo\bar\baz`, `c:\foo\woo\wee`)); // `..\..\bar\baz`
    writeln(relativePath(`c:\foo\bar\baz`, `c:\foo\bar`)); // "baz"
    writeln(relativePath(`c:\foo\bar`, `d:\foo`)); // `c:\foo\bar`
}

。 memoryメモリ

auto asRelativePath(CaseSensitive cs = CaseSensitive.osDefault, R1, R2)(R1 path, R2 base) if ((isNarrowString!R1 || isRandomAccessRange!R1 && hasSlicing!R1 && isSomeChar!(ElementType!R1) && !isConvertibleToString!R1) && (isNarrowString!R2 || isRandomAccessRange!R2 && hasSlicing!R2 && isSomeChar!(ElementType!R2) && !isConvertibleToString!R2));

変換 path相対パスに変換する base。

返されたパスは、 base通常は現在の作業ディレクトリである。 base絶対パスでなければならず、常にディレクトリを参照しているものと見なされます。 pathおよび base同じディレクトリを参照している場合、関数は'.' を返します。

次のアルゴリズムが使用されます。

相対ディレクトリの場合は、そのまま返す。 path相対ディレクトリである場合は、そのまま返す。
との共通のルートを見つけ、 path。 base。共通のルートが見つからなければ、 pathそのまま返す。
ベースパスから共通ルートに到達するために必要な数の../ または..\ を含む文字列を準備する。
残りのセグメントを path文字列に追加し、戻り値を返す。

2番目のステップでは、パスコンポーネントがfilenameCmp!cs を使用して比較される。ここで、cs はオプションのテンプレートパラメータであり、比較が大文字と小文字を区別するかどうかを決定する。詳細は filenameCmp詳細はドキュメントを参照のこと。

internalinternal

Parameters:

R1 `path`	変換するパス
R2 `base`	絶対パス
cs	ファイル指定の比較が敏感であるか否かを指定する。デフォルトは CaseSensitive.osDefault

Returns: ランダムにアクセス可能な変換後のパスの範囲

ランダムにアクセス可能な変換後のパスの範囲

range範囲

See Also:

relativePath

range範囲

Examples:

import std.array;
version (Posix)
{
    writeln(asRelativePath("foo", "/bar").array); // "foo"
    writeln(asRelativePath("/foo/bar", "/foo/bar").array); // "."
    writeln(asRelativePath("/foo/bar", "/foo/baz").array); // "../bar"
    writeln(asRelativePath("/foo/bar/baz", "/foo/woo/wee").array); // "../../bar/baz"
    writeln(asRelativePath("/foo/bar/baz", "/foo/bar").array); // "baz"
}
else version (Windows)
{
    writeln(asRelativePath("foo", `c:\bar`).array); // "foo"
    writeln(asRelativePath(`c:\foo\bar`, `c:\foo\bar`).array); // "."
    writeln(asRelativePath(`c:\foo\bar`, `c:\foo\baz`).array); // `..\bar`
    writeln(asRelativePath(`c:\foo\bar\baz`, `c:\foo\woo\wee`).array); // `..\..\bar\baz`
    writeln(asRelativePath(`c:/foo/bar/baz`, `c:\foo\woo\wee`).array); // `..\..\bar\baz`
    writeln(asRelativePath(`c:\foo\bar\baz`, `c:\foo\bar`).array); // "baz"
    writeln(asRelativePath(`c:\foo\bar`, `d:\foo`).array); // `c:\foo\bar`
    writeln(asRelativePath(`\\foo\bar`, `c:\foo`).array); // `\\foo\bar`
}
else
    static assert(0);

ファイル名の文字を比較する。

pure nothrow @safe int filenameCharCmp(CaseSensitive cs = CaseSensitive.osDefault)(dchar a, dchar b);

ファイル名の文字を比較する。

この関数は、大文字と小文字を区別して比較することも、区別せずに比較することもできる。これは、cs テンプレートパラメータで制御する。指定されていない場合は、 CaseSensitive.osDefault。

Windowsでは、バックスラッシュとスラッシュ文字(\)は /)は同等とみなされます。

Parameters:

cs	比較の大文字・小文字の区別。
dchar `a`	ファイル名の文字。
dchar `b`	ファイル名文字。

character文字

Returns: xml-ph-0000@deepl.internal の場合は、xml-ph-0001@deepl.internal の場合はxml-ph-0002@deepl.internal 、xml-

< 0 a < b > 0 の場合は、の場合は、の場合は。0 a == b a > b

emailemail

Examples:

writeln(filenameCharCmp('a', 'a')); // 0
assert(filenameCharCmp('a', 'b') < 0);
assert(filenameCharCmp('b', 'a') > 0);

version (linux)
{
    // filenameCharCmp!(CaseSensitive.yes)(a, b)を呼び出すのと同じ
    assert(filenameCharCmp('A', 'a') < 0);
    assert(filenameCharCmp('a', 'A') > 0);
}
version (Windows)
{
    // filenameCharCmp!(CaseSensitive.no)(a, b)を呼び出すのと同じ
    writeln(filenameCharCmp('a', 'A')); // 0
    assert(filenameCharCmp('a', 'B') < 0);
    assert(filenameCharCmp('A', 'b') < 0);
}

int filenameCmp(CaseSensitive cs = CaseSensitive.osDefault, Range1, Range2)(Range1 filename1, Range2 filename2) if (isSomeFiniteCharInputRange!Range1 && !isConvertibleToString!Range1 && isSomeFiniteCharInputRange!Range2 && !isConvertibleToString!Range2);

ファイル名を比較し、

個々の文字はfilenameCharCmp!cs を使用して比較され、cs はオプションのテンプレートパラメータであり、比較が大文字と小文字を区別するかどうかを決定する。

無効なUTFエンコーディングの処理は処理系定義である。

Parameters:

cs	大文字と小文字の区別
Range1 `filename1`	最初のファイル名の範囲
Range2 `filename2`	2番目のファイル名の範囲

range範囲

Returns:

< 0 filename1 < filename2 の場合、の場合、の場合。0 filename1 == filename2 > 0 filename1 > filename2

See Also:

filenameCharCmp

internal内部

Examples:

writeln(filenameCmp("abc", "abc")); // 0
assert(filenameCmp("abc", "abd") < 0);
assert(filenameCmp("abc", "abb") > 0);
assert(filenameCmp("abc", "abcd") < 0);
assert(filenameCmp("abcd", "abc") > 0);

version (linux)
{
    // filenameCmp!(CaseSensitive.yes)(filename1, filename2)を呼び出すのと同じ
    assert(filenameCmp("Abc", "abc") < 0);
    assert(filenameCmp("abc", "Abc") > 0);
}
version (Windows)
{
    // filenameCmp!(CaseSensitive.no)(filename1, filename2)を呼び出すのと同じ
    writeln(filenameCmp("Abc", "abc")); // 0
    writeln(filenameCmp("abc", "Abc")); // 0
    assert(filenameCmp("Abc", "abD") < 0);
    assert(filenameCmp("abc", "AbB") > 0);
}

Matches一致する

pure nothrow @safe bool globMatch(CaseSensitive cs = CaseSensitive.osDefault, C, Range)(Range path, const(C)[] pattern) if (isForwardRange!Range && !isInfinite!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range && isSomeChar!C && is(immutable(C) == immutable(ElementEncodingType!Range)));

パスに対してパターンを一致させる。

パターンの一部の文字は特別な意味を持ち( メタ文字)、エスケープできない。これらは以下のとおりである。


*	任意の文字を0回以上一致させる。
?	任意の文字を1つだけ正確に一致させる。
[文字]	角括弧内に表示される任意の文字を1つ一致させます。
[!chars]	任意の文字が1つ一致する。ただし、感嘆符の後の括弧内にない文字である。
{string1,string2,…}	いずれかの指定文字列に一致する。

個々の文字はfilenameCharCmp!cs を使用して比較され、cs は比較が大文字と小文字を区別するかどうかを決定するオプションのテンプレートパラメータである。詳細は filenameCharCmp。

ディレクトリ区切り文字やドットは、メタ文字がパスのさらに他の部分に一致するのを妨げるものではない。

Parameters:

cs	一致させる際に大文字と小文字を区別するかどうか
Range `path`	一致させるパス
const(C)[] `pattern`	ワイルドカードパターン

Returns: パターンがパスに一致する場合、xml-ph-0000@deepl.internal それ以外の場合。

true パターンがパスに一致する場合、それ以外の場合。false

See Also:

Wikipedia: glob (programming)

globglob

Examples:

assert(globMatch("foo.bar", "*"));
assert(globMatch("foo.bar", "*.*"));
assert(globMatch(`foo/foo\bar`, "f*b*r"));
assert(globMatch("foo.bar", "f???bar"));
assert(globMatch("foo.bar", "[fg]???bar"));
assert(globMatch("foo.bar", "[!gh]*bar"));
assert(globMatch("bar.fooz", "bar.{foo,bif}z"));
assert(globMatch("bar.bifz", "bar.{foo,bif}z"));

version (Windows)
{
    // globMatch!(CaseSensitive.no)(path, pattern)を呼び出すのと同じ
    assert(globMatch("foo", "Foo"));
    assert(globMatch("Goo.bar", "[fg]???bar"));
}
version (linux)
{
    // globMatch!(CaseSensitive.yes)(path, pattern)を呼び出すのと同じ
    assert(!globMatch("foo", "Foo"));
    assert(!globMatch("Goo.bar", "[fg]???bar"));
}

与えられたファイル名またはディレクトリ名が有効であるかどうかを調べる。

bool isValidFilename(Range)(Range filename) if ((isRandomAccessRange!Range && hasLength!Range && hasSlicing!Range && isSomeChar!(ElementEncodingType!Range) || isNarrowString!Range) && !isConvertibleToString!Range);

与えられたファイル名またはディレクトリ名が有効であるかどうかを確認する。

最大長は filename定数core.stdc.stdio.FILENAME_MAX によって与えられる。 (Windowsでは、この数値は UTF-16のコードポイントの最大数として定義されており、したがって、このテストは filename文字列がwcharである場合のみ、厳密に正しい結果が得られる。

Windowsでは、以下の基準を満たす必要がある (出典):

filename整数表現が0から31の範囲の文字を含んではならない。
filename以下の予約文字を含んではならない。<>:"/\|?*
filenameスペース(' ' )またはピリオド('.' )で終わってはならない。

POSIXでは、 filenameスラッシュ('/' )またはヌル文字('\0' )を含んではならない。

Parameters:

Range filename 確認用の文字列

Returns:

truefilename空ではなく、長すぎず、無効な文字を含んでいない場合にのみ、

ifか

Examples:

import std.utf : byCodeUnit;

assert(isValidFilename("hello.exe".byCodeUnit));

bool isValidPath(Range)(Range path) if ((isRandomAccessRange!Range && hasLength!Range && hasSlicing!Range && isSomeChar!(ElementEncodingType!Range) || isNarrowString!Range) && !isConvertibleToString!Range);

が有効なパスであるかどうかを確認する。 path有効なパスであるかどうかを

通常、この関数は、 path空ではないこと、およびパスの各コンポーネントが isValidFilename または"." または".." に等しいことを確認します。

この関数は、パスが既存のファイルまたはディレクトリを指しているかどうかは確認しません。 この目的にはstd.file.exists を使用してください。

Windowsでは、いくつかの特別なルールが適用されます。

の2番目の文字が pathコロン(':' )である場合、最初の文字はドライブ文字として解釈され、 A-Z(大文字・小文字の区別なし)の範囲でなければなりません。
path形式( \\server\share\... (UNCパス)の場合、 isValidFilenameサーバーと共有にも適用される。
pathが(長いUNCパス)で始まる場合、 \\?\(長いUNCパス)で始まる場合、文字列の残りの部分の唯一の要件は、ヌル文字を含まないことである。
pathが \\.\(Win32 デバイスネームスペース)で始まる場合、この関数はfalse を返します。このようなパスは、このモジュールの対象外です。

moduleモジュール

Parameters: 文字列または文字の範囲を指定して確認する

Range path 文字列または文字の範囲を指定して確認する

Returns:

有効なパスである場合は「true」と path有効なパスであるかどうかを

range範囲

Examples:

assert(isValidPath("/foo/bar"));
assert(!isValidPath("/foo\0/bar"));
assert(isValidPath("/"));
assert(isValidPath("a"));

version (Windows)
{
    assert(isValidPath(`c:\`));
    assert(isValidPath(`c:\foo`));
    assert(isValidPath(`c:\foo\.\bar\\\..\`));
    assert(!isValidPath(`!:\foo`));
    assert(!isValidPath(`c::\foo`));
    assert(!isValidPath(`c:\foo?`));
    assert(!isValidPath(`c:\foo.`));

    assert(isValidPath(`\\server\share`));
    assert(isValidPath(`\\server\share\foo`));
    assert(isValidPath(`\\server\share\\foo`));
    assert(!isValidPath(`\\\server\share\foo`));
    assert(!isValidPath(`\\server\\share\foo`));
    assert(!isValidPath(`\\ser*er\share\foo`));
    assert(!isValidPath(`\\server\sha?e\foo`));
    assert(!isValidPath(`\\server\share\|oo`));

    assert(isValidPath(`\\?\<>:"?*|/\..\.`));
    assert(!isValidPath("\\\\?\\foo\0bar"));

    assert(!isValidPath(`\\.\PhysicalDisk1`));
    assert(!isValidPath(`\\`));
}

import std.utf : byCodeUnit;
assert(isValidPath("/foo/bar".byCodeUnit));

nothrow @safe string expandTilde(return scope const string inputPath);

POSIXシステムでは、パス内のチルダの展開を行う。 Windowsでは、この関数は何も行わない。

パス名でチルダ展開を使用するには2つの方法がある。 1つはチルダのみを使用する方法、またはチルダの後にパス区切り文字を続ける方法である。この場合、チルダは環境変数HOME の値で展開される。 2つ目の方法は、チルダの後にユーザ名を続ける方法である(例:~john/Mail )。この場合、ユーザ名はユーザデータベース(例:Unixシステムでは )で検索され、 (すなわち、Unixシステムでは/etc/passwd )で、そこに保存されているパスに展開される。ユーザー名は、チルダの後に続く文字列で、パス区切り文字の最初のインスタンスで終了するものと見なされる。

~user 構文を使用すると、環境変数がユーザーデータベースに保存されている値と一致しない場合、~ と異なる値が返される可能性があることに注意すること。

環境変数バージョンが使用される場合、環境変数が存在しない場合、または空の場合、パスは変更されない。データベースバージョンが使用される場合、データベースにユーザーが存在しない場合、またはクエリを実行するのに十分なメモリがない場合、パスは変更されない。

この関数は、いくつかのメモリ割り当てを実行する。

Parameters:

string inputPath 展開するパス名。

Returns: チルダが展開されたもの、または単に

inputPathチルダが展開されたもの、または inputPath 展開できなかった場合は、 Windowsでは、 expandTilde単にその引数を返す inputPath。

例

void processFile(string path)
{
    // この関数を~/fooのようなパスで呼び出せるようにする
    auto fullPath = expandTilde(path);
    ...
}

example例

Examples:

version (Posix)
{
    import std.process : environment;

    auto oldHome = environment["HOME"];
    scope(exit) environment["HOME"] = oldHome;

    environment["HOME"] = "dmd/test";
    writeln(expandTilde("~/")); // "dmd/test/"
    writeln(expandTilde("~")); // "dmd/test"
}

example例

DEEPL APIにより翻訳、ところどころ修正。
このページの最新版(英語)
このページの原文(英語)
翻訳時のdmdのバージョン: 2.109.1
ドキュメントのdmdのバージョン: 2.109.1
翻訳日付 :2025-01-02 22:38:04+09:00
HTML生成日時: 2025-01-09 08:10:34+09:00
編集者: dokutoku

言語リファレンス

std.path