Path (computing)

A path (or filepath, file path, pathname, or similar) is a string that uniquely identifies an item in a hierarchical file system. Generally, a path is composed of directory names, special format specifiers, and optionally a filename, all separated by delimiters. This delimiter can vary by operating system, but popular, modern systems use the slash Template:Code, backslash Template:Code, or colon Template:Code.

The case-sensitivity of individual path components will vary based on operating system, or based on options specified at the time of a file system's creation or first use. In practice, this means that for a case-sensitive system, path components named Template:Code and Template:Code can coexist at the same level in the hierarchy, whereas for a case-insensitive file system, they cannot (an error will occur). macOS and Windows' native file systems are case-insensitive by default, whereas typical Linux file systems are case-sensitive.<ref>Template:Cite web Includes a description of APFS, the default file system for macOS</ref><ref>Template:Cite web Windows file system treats file and directory names as case-insensitive. FOO.txt and foo.txt will be treated as equivalent files. Linux file system treats file and directory names as case-sensitive. FOO.txt and foo.txt will be treated as distinct files.</ref><ref>Template:Cite web Case sensitivity in Linux refers to files and directories recognizing differences between lowercase and uppercase characters in filenames. For instance, "File.txt" and "file.txt" would both be treated as two distinct files. This concept is integral to Unix-like operating systems, including Linux.</ref>

Template:AnchorTemplate:AnchorA path can be either relative or absolute. A relative path is a path in relation to another, most often the working directory. An absolute path indicates a location regardless of the current directory; that is, it specifies all path components starting from the file system's root, and does not depend on context like a relative path does.

Paths are also essential for locating hierarchically-organized network resources, as seen in URLs and UNC paths.

History

Multics first introduced a hierarchical file system with directories (separated by ">") in the mid-1960s.<ref>Template:Cite conference</ref>

Around 1970, Unix introduced the slash Template:Code as its directory separator.

Originally, MS-DOS did not support directories. When adding the feature, using the Unix standard of a slash was not a good option since many existing commands used a slash as the switch prefix (i.e., Template:Code). In contrast, Unix uses the dash Template:Code as the switch prefix. The backslash Template:Code was ultimately chosen instead for its similarity to the slash and not conflicting with existing commands. This convention continued into Windows. However, some areas of Windows do accept or understand Unix-style slashes also, such as PowerShell.<ref>Template:Cite web</ref><ref>Template:Cite web</ref>

Summary of systems

The following table describes the syntax of paths in notable operating systems:Template:Table alignment

In programming languages

Most programming languages use the path representation of the underlying system, but some may also be system-independent.

For instance, this C code is system-dependent and may fail on opposing systems:

<syntaxhighlight lang="c">uxFile = fopen("project/readme.txt", "r") // Fails on Windows winFile = fopen("C:\\Program Files\\bin\\config.bat", "r") // Fails on Unix </syntaxhighlight>

• In Java, the Template:Var field stores the system-dependent separator.<ref>Template:Cite web</ref> Some functions preclude the need for the separator entirely.

<syntaxhighlight lang="java">import java.io.File;

import java.nio.file.Path; import java.nio.file.Paths; // ... File file = new File("path" + File.separator + "file.txt"); Path path = Paths.get("path", "file.txt"); </syntaxhighlight>

• In Python, the Template:Code module offers system-independent path operations.<ref>Template:Cite web</ref>

<syntaxhighlight lang="python">from pathlib import Path

with (Path("path") / "to" / "file.txt").open() as open_file:

   ...

</syntaxhighlight>

In Unix

Most Unix-like systems use a similar syntax.<ref>Template:Cite web</ref> POSIX allows treating a path beginning with two slashes in an implementation-defined manner,<ref>Template:Cite web</ref> though in other cases systems must treat consecutive slashes as one.<ref>Template:Cite web</ref>

Many applications on Unix-like systems (for example, scp, rcp, and rsync) use resource definitions such as Template:Code, or URI schemes with the service name (here 'smb'), like Template:Code.

In macOS

When macOS was being developed, it inherited some pathname choices from Classic Mac OS and the Unix-like NeXTSTEP. The classic Mac OS uses a Template:Code while Unix and Unix-like systems use a Template:Code as the path delimiter. As a solution, to preserve compatibility for software and familiarity for users, and to allow disk file systems to be used both by the classic Mac OS and macOS, some portions of macOS convert between colons and slashes in pathnames;<ref>Template:Cite web</ref> for example, the HFS+ file system, from the classic Mac OS, converts colons in file names to slashes and, when reading a directory, converts slashes in filenames to colons,<ref name="sanchez-usenix">Template:Cite web</ref> as and the Carbon toolkit converts colons in pathnames to slashes and slashes in path names to colons, and converts them back when providing filenames and pathnames to the caller.<ref name="sanchez-usenix" />

In DOS and Windows

Screenshot of a Windows Command Prompt shell showing filenames in a directory

DOS and Windows have no single root directory; a root exists for each storage drive, indicated with a drive letter or through UNC.

Directory and file name comparisons are case-insensitive: "test.TXT" would match "Test.txt".<ref name="netpaths" />

Windows understands the following kinds of paths:

• Local paths, such as Template:Code.
• Universal naming convention (UNC).
• DOS device paths, such as Template:Code or Template:Code. The first, Template:Code skips path normalization. The second, Template:Code uses the raw device namespace.<ref name="netpaths">Template:Cite web</ref><ref name="w32paths">Template:Cite web</ref>

In the Windows API, file I/O functions automatically convert Template:Code into Template:Code (except when using the Template:Code prefix). Unless the Template:Code prefix is used, paths are limited to the length defined by Template:Var, which is 260.<ref>Template:Cite web</ref>

PowerShell allows slash-interoperability for backwards-compatibility:<ref>Template:Cite web</ref>

<syntaxhighlight lang="powershell">PS C:\>Get-Content -Path "C:/path/to/file.txt"

Here is some text within a file</syntaxhighlight>

Yen/won character error

Japanese and Korean versions of Windows often displayed the '¥' character or the '₩' character instead of the directory separator. This is because while in ANSI codepages, the character at 0x5C was the backslash, and in Japanese and Korean codepages, 0x5C was the yen and won signs, respectively. Therefore, when the character for a backslash was used, other glyphs appeared.<ref>Template:Cite web</ref>

Universal Naming Convention

The Microsoft Universal Naming Convention (UNC, uniform naming convention, or network path), is a syntax to describe the location of a network resource, such as a shared file, directory, or printer. A UNC path has the general form:

Some Windows interfaces allow or require UNC syntax for WebDAV share access, rather than a URL. The UNC syntax is extended with optional components to denote use of SSL and TCP/IP port number. Thus, the WebDAV URL of Template:Code becomes Template:Code.<ref>Template:Cite web</ref>

When viewed remotely, the "SharedFolder" may have a name different from what a program on the server sees when opening "\SharedFolder". Instead, the SharedFolder name consists of an arbitrary name assigned to the folder when defining its "sharing".

Since UNCs start with two backslashes, and the backslash is also used for escape sequences and in regular expressions, cases of leaning toothpick syndrome may arise. An escaped string for a regular expression matching a UNC begins with 8 backslashes Template:Code because the string and regular expression both require escaping. This can be simplified by using raw strings, such as Template:Code in C#, Template:Code in Python, or Template:Code in Perl.

See also

• Template:Annotated link
• Template:Annotated link
• Template:Annotated link
• Template:Annotated link
• Template:Annotated link
• Template:Annotated link
• Template:Annotated link
• Template:Annotated link
• Template:Annotated link