URL

standardizedFileURL

get standardizedFileURL(): string

var standardizedFileURL: URL { get }

A standardized version of the path of a file URL. If the `isFileURL` is false, this method returns `self`.

baseURL

get baseURL(): (string) | null

var baseURL: URL? { get }

The base URL. If the URL is itself absolute, then this value is `nil`.

isFileURL

get isFileURL(): boolean

var isFileURL: Bool { get }

A Boolean that is true if the scheme is `file:`.

absoluteURL

get absoluteURL(): string

var absoluteURL: URL { get }

The absolute URL. If the URL is itself absolute, this returns `self`.

description

get description(): string

var description: String { get }

A textual representation of this instance. Calling this property directly is discouraged. Instead, convert an instance of any type to a string by using the `String(describing:)` initializer. This initializer works with any type, and uses the custom `description` property for types that conform to `CustomStringConvertible`: struct Point: CustomStringConvertible { let x: Int, y: Int var description: String { return "(\(x), \(y))" } } let p = Point(x: 21, y: 30) let s = String(describing: p) print(s) // Prints "(21, 30)" The conversion of `p` to a string in the assignment to `s` uses the `Point` type's `description` property.

standardize

standardize(): void

mutating func standardize()

Standardizes the path of a file URL. If the `isFileURL` is false, this method does nothing.

bookmarkData

static bookmarkDataWithContentsOf(url: string): ArrayBuffer

static func bookmarkData(withContentsOf url: URL) throws -> Data

Initializes and returns bookmark data derived from an alias file pointed to by a specified URL. If bookmarkFileURL refers to an alias file created prior to OS X v10.6 that contains Alias Manager information but no bookmark data, this method synthesizes bookmark data for the file.

bookmarkData

bookmarkDataOptionsIncludingResourceValuesForKeysRelativeTo(options?: NSURL_BookmarkCreationOptions, keys?: (Array<URLResourceKey>) | null, url?: (string) | null): ArrayBuffer

func bookmarkData(options: URL.BookmarkCreationOptions = [], includingResourceValuesForKeys keys: Set<URLResourceKey>? = nil, relativeTo url: URL? = nil) throws -> Data

Returns bookmark data for the URL, created with specified options and resource values.

relativePath

get relativePath(): string

var relativePath: String { get }

The relative path of the URL if the URL conforms to RFC 3986, otherwise nil. This is the same as `path` if `baseURL` is `nil`. - Returns: The relative path, or an empty string if the URL has an empty path.

standardized

get standardized(): string

var standardized: URL { get }

A version of the URL with any instances of ".." or "." resolved in its path.

homeDirectory

static homeDirectoryForUser(user: string): (string) | null

static func homeDirectory(forUser user: String) -> URL?

Returns the home directory for the specified user.

homeDirectory

static get homeDirectory(): string

static var homeDirectory: URL { get }

The home directory for the current user. This URL is the equivalent of the shell value `~/`. Complexity: O(1)

pathExtension

get pathExtension(): string

var pathExtension: String { get }

The path extension of the URL, or an empty string if the path is an empty string.

resourceBytes

get resourceBytes(): URL_AsyncBytes

var resourceBytes: URL.AsyncBytes { get }

The URL's resource data, as an asynchronous sequence of bytes. Use this property with Swift's `for`-`await`-`in` syntax, to read the contents of a URL byte-by-byte. To wait for the entire resource to load, use the ``URLSession`` method ``URLSession/data(from:delegate:)`` with the `await` keyword.

userDirectory

static get userDirectory(): string

static var userDirectory: URL { get }

The user home directories directory. Complexity: O(n) where n is the number of significant directories specified by `FileManager.SearchPathDirectory`

absoluteString

get absoluteString(): string

var absoluteString: String { get }

The absolute string for the URL.

musicDirectory

static get musicDirectory(): string

static var musicDirectory: URL { get }

The music directory for the current user. Complexity: O(n) where n is the number of significant directories specified by `FileManager.SearchPathDirectory`

pathComponents

get pathComponents(): Array<string>

var pathComponents: [String] { get }

The path components of the URL, or an empty array if the path is an empty string.

relativeString

get relativeString(): string

var relativeString: String { get }

The relative portion of a URL. If `baseURL` is nil, or if the receiver is itself absolute, this is the same as `absoluteString`.

resourceValues

static resourceValuesForKeysFromBookmarkData(keys: Array<URLResourceKey>, data: ArrayBuffer): (URLResourceValues) | null

static func resourceValues(forKeys keys: Set<URLResourceKey>, fromBookmarkData data: Data) -> URLResourceValues?

Returns the resource values for properties identified by a specified array of keys contained in specified bookmark data. If the result dictionary does not contain a resource value for one or more of the requested resource keys, it means those resource properties are not available in the bookmark data.

resourceValues

resourceValuesForKeys(keys: Array<URLResourceKey>): URLResourceValues

func resourceValues(forKeys keys: Set<URLResourceKey>) throws -> URLResourceValues

Return a collection of resource values identified by the given resource keys. This method first checks if the URL object already caches the resource value. If so, it returns the cached resource value to the caller. If not, then this method synchronously obtains the resource value from the backing store, adds the resource value to the URL object's cache, and returns the resource value to the caller. The type of the resource value varies by resource property (see resource key definitions). If this method does not throw and the resulting value in the `URLResourceValues` is populated with nil, it means the resource property is not available for the specified resource and no errors occurred when determining the resource property was not available. This method is currently applicable only to URLs for file system resources. When this function is used from the main thread, resource values cached by the URL (except those added as temporary properties) are removed the next time the main thread's run loop runs. `func removeCachedResourceValue(forKey:)` and `func removeAllCachedResourceValues()` also may be used to remove cached resource values. Only the values for the keys specified in `keys` will be populated.

trashDirectory

static get trashDirectory(): string

static var trashDirectory: URL { get }

The trash directory for the current user. Complexity: O(n) where n is the number of significant directories specified by `FileManager.SearchPathDirectory`

cachesDirectory

static get cachesDirectory(): string

static var cachesDirectory: URL { get }

The standard directory for discardable cache files. Complexity: O(n) where n is the number of significant directories specified by `FileManager.SearchPathDirectory`

init

static initFileURLWithPathRelativeTo(path: string, base?: (string) | null): string

init(fileURLWithPath path: String, relativeTo base: URL?)

Creates a file URL that references the local file or directory at the given path, relative to a base URL. - Parameters: - path: The location in the file system. - base: A base URL to resolve the path against. If an empty string is used for the path, the system interprets it as ".".

init

static initFileURLWithPathIsDirectoryRelativeTo(path: string, isDirectory: boolean, base?: (string) | null): string

init(fileURLWithPath path: String, isDirectory: Bool, relativeTo base: URL?)

Creates a file URL that references the local file or directory at the given path, relative to a base URL. - Parameters: - path: The location in the file system. - isDirectory: A Boolean value that indicates whether the path references a directory. - base: A base URL to resolve the path against. If an empty string is used for the path, the system interprets it as ".". - Note: This function avoids an extra file system access to check if the file URL is a directory. You should use it if you know the answer already.

init

static initFileURLWithPathIsDirectory(path: string, isDirectory: boolean): string

init(fileURLWithPath path: String, isDirectory: Bool)

Creates a file URL that references the local file or directory at the given path. - Parameters: - path: The location in the file system. - isDirectory: A Boolean value that indicates whether the path references a directory. If an empty string is used for the path, the system interprets it as ".". - Note: This function avoids an extra file system access to check if the file URL is a directory. You should use it if you know the answer already.

init

static initFileURLWithPath(path: string): string

init(fileURLWithPath path: String)

Creates a file URL that references the local file or directory at the given path. - Parameter path: The location in the file system. If an empty string is used for the path, the system interprets it as ".".

moviesDirectory

static get moviesDirectory(): string

static var moviesDirectory: URL { get }

The movies directory for the current user. Complexity: O(n) where n is the number of significant directories specified by `FileManager.SearchPathDirectory`

currentDirectory

static currentDirectory(): string

static func currentDirectory() -> URL

The working directory of the current process. Calling this property will issue a `getcwd` syscall.

debugDescription

get debugDescription(): string

var debugDescription: String { get }

A textual representation of this instance, suitable for debugging. Calling this property directly is discouraged. Instead, convert an instance of any type to a string by using the `String(reflecting:)` initializer. This initializer works with any type, and uses the custom `debugDescription` property for types that conform to `CustomDebugStringConvertible`: struct Point: CustomDebugStringConvertible { let x: Int, y: Int var debugDescription: String { return "(\(x), \(y))" } } let p = Point(x: 21, y: 30) let s = String(reflecting: p) print(s) // Prints "(21, 30)" The conversion of `p` to a string in the assignment to `s` uses the `Point` type's `debugDescription` property.

desktopDirectory

static get desktopDirectory(): string

static var desktopDirectory: URL { get }

The desktop directory for the current user. Complexity: O(n) where n is the number of significant directories specified by `FileManager.SearchPathDirectory`

hasDirectoryPath

get hasDirectoryPath(): boolean

var hasDirectoryPath: Bool { get }

A Boolean that is true if the URL path represents a directory.

libraryDirectory

static get libraryDirectory(): string

static var libraryDirectory: URL { get }

The library directory for the current user. Complexity: O(n) where n is the number of significant directories specified by `FileManager.SearchPathDirectory`

lastPathComponent

get lastPathComponent(): string

var lastPathComponent: String { get }

The last path component of the URL, or an empty string if the path is an empty string.

picturesDirectory

static get picturesDirectory(): string

static var picturesDirectory: URL { get }

The pictures directory for the current user. Complexity: O(n) where n is the number of significant directories specified by `FileManager.SearchPathDirectory`

setResourceValues

setResourceValues(values: URLResourceValues): void

mutating func setResourceValues(_ values: URLResourceValues) throws

Sets the resource value identified by a given resource key. This method writes the new resource values out to the backing store. Attempts to set a read-only resource property or to set a resource property not supported by the resource are ignored and are not considered errors. This method is currently applicable only to URLs for file system resources. `URLResourceValues` keeps track of which of its properties have been set. Those values are the ones used by this function to determine which properties to write.

writeBookmarkData

static writeBookmarkData(data: ArrayBuffer, url: string): void

static func writeBookmarkData(_ data: Data, to url: URL) throws

Creates an alias file on disk at a specified location with specified bookmark data. bookmarkData must have been created with the URLBookmarkCreationSuitableForBookmarkFile option. bookmarkFileURL must either refer to an existing file (which will be overwritten), or to location in an existing directory.

init

static initDataRepresentationRelativeToIsAbsolute(dataRepresentation: ArrayBuffer, base?: (string) | null, isAbsolute?: boolean): (string) | null

init?(dataRepresentation: Data, relativeTo base: URL?, isAbsolute: Bool = false)

Initializes a newly created URL using the contents of the given data, relative to a base URL. If the data representation isn't a legal URL string as ASCII bytes, the URL object may not behave as expected. This initializer returns `nil` if it can't form a valid URL from the provided data.

dataRepresentation

get dataRepresentation(): ArrayBuffer

var dataRepresentation: Data { get }

The data representation of the URL's relativeString. If the URL was initialized with `init?(dataRepresentation:relativeTo:isAbsolute:)`, the data representation returned are the same bytes as those used at initialization; otherwise, the data representation returned are the bytes of the `relativeString` encoded with UTF8 string encoding.

documentsDirectory

static get documentsDirectory(): string

static var documentsDirectory: URL { get }

The standard directory for document files. Complexity: O(n) where n is the number of significant directories specified by `FileManager.SearchPathDirectory`

downloadsDirectory

static get downloadsDirectory(): string

static var downloadsDirectory: URL { get }

The downloads directory for the current user. Complexity: O(n) where n is the number of significant directories specified by `FileManager.SearchPathDirectory`

temporaryDirectory

static get temporaryDirectory(): string

static var temporaryDirectory: URL { get }

The standard directory for temporary files. Complexity: O(1)

appendPathComponent

appendPathComponentIsDirectory(pathComponent: string, isDirectory: boolean): void

mutating func appendPathComponent(_ pathComponent: String, isDirectory: Bool)

Appends a path component to the URL. - parameter pathComponent: The path component to add. - parameter isDirectory: Use `true` if the resulting path is a directory.

appendPathComponent

appendPathComponent(pathComponent: string): void

mutating func appendPathComponent(_ pathComponent: String)

Appends a path component to the URL. > Note: This function performs a file system operation to determine if > the path component is a directory. If so, it will append a trailing > `/`. If you know in advance that the path component is a directory or > not, then use `func appendingPathComponent(_:isDirectory:)`. New code should use ``URL/append(path:directoryHint:)`` instead of this method. - Parameter pathComponent: The path component to add.

appendPathExtension

appendPathExtension(pathExtension: string): void

mutating func appendPathExtension(_ pathExtension: String)

Appends the given path extension to self. If the URL has an empty path (e.g., `http://www.example.com`), then this function will do nothing. Certain special characters (for example, Unicode Right-To-Left marks) cannot be used as path extensions. If any of those are contained in `pathExtension`, the function will return the URL unchanged. - parameter pathExtension: The extension to append.

deletePathExtension

deletePathExtension(): void

mutating func deletePathExtension()

Returns a URL constructed by removing any path extension. If the URL has an empty path (e.g., `http://www.example.com`), then this function will do nothing.

applicationDirectory

static get applicationDirectory(): string

static var applicationDirectory: URL { get }

The standard directory for apps. Complexity: O(n) where n is the number of significant directories specified by `FileManager.SearchPathDirectory`

init

static initResolvingAliasFileAtOptions(url: string, options?: NSURL_BookmarkResolutionOptions): string

init(resolvingAliasFileAt url: URL, options: URL.BookmarkResolutionOptions = []) throws

Creates a URL that refers to the location specified by resolving an alias file. If the `url` argument doesn't refer to an alias file (as defined by the ``URLResourceKey/isAliasFileKey`` property), the returned URL is the same as the `url` argument. This method throws an error if the url argument is unreachable, the original file or directory is unknown or unreachable, or the original file or directory is on a volume that the system can't locate or mount. This method doesn't support the ``NSURL/BookmarkResolutionOptions/withSecurityScope`` option.

deletingPathExtension

deletingPathExtension(): string

func deletingPathExtension() -> URL

Returns a URL constructed by removing any path extension. If the URL has an empty path (e.g., `http://www.example.com`), then this function will return the URL unchanged.

resolveSymlinksInPath

resolveSymlinksInPath(): void

mutating func resolveSymlinksInPath()

Resolves any symlinks in the path of a file URL. If the `isFileURL` is false, this method does nothing.

init

static initResolvingBookmarkDataOptionsRelativeToBookmarkDataIsStale(data: ArrayBuffer, options: NSURL_BookmarkResolutionOptions, url: (string) | null, bookmarkDataIsStale: boolean): { $ret: (string) | null; $out: { "bookmarkDataIsStale": boolean } }

init?(resolvingBookmarkData data: Data, options: URL.BookmarkResolutionOptions = [], relativeTo url: URL? = nil, bookmarkDataIsStale: inout Bool) throws

Initializes a URL that refers to a location specified by resolving bookmark data.

Omit the output parameters from the call. The result contains $ret and $out, with bookmarkDataIsStale inside $out.

init

static initResolvingBookmarkDataOptionsRelativeToBookmarkDataIsStale67726(data: ArrayBuffer, options: NSURL_BookmarkResolutionOptions, url: (string) | null, bookmarkDataIsStale: boolean): { $ret: string; $out: { "bookmarkDataIsStale": boolean } }

init(resolvingBookmarkData data: Data, options: URL.BookmarkResolutionOptions = [], relativeTo url: URL? = nil, bookmarkDataIsStale: inout Bool) throws

Creates a URL that refers to a location specified by resolving bookmark data. - Parameters: - data: The bookmark data used to construct a URL. - options: Options taken into account when resolving the bookmark data. - url: The base URL that the bookmark data is relative to. - bookmarkDataIsStale: On return, if `true`, the bookmark data is stale. Your app should create a new bookmark using the returned URL and use it in place of any stored copies of the existing bookmark.

Omit the output parameters from the call. The result contains $ret and $out, with bookmarkDataIsStale inside $out.

sharedPublicDirectory

static get sharedPublicDirectory(): string

static var sharedPublicDirectory: URL { get }

The user’s public sharing directory. Complexity: O(n) where n is the number of significant directories specified by `FileManager.SearchPathDirectory`

appendingPathComponent

appendingPathComponentIsDirectory(pathComponent: string, isDirectory: boolean): string

func appendingPathComponent(_ pathComponent: String, isDirectory: Bool) -> URL

Returns a URL constructed by appending the given path component to self. - parameter pathComponent: The path component to add. - parameter isDirectory: If `true`, then a trailing `/` is added to the resulting path.

appendingPathComponent

appendingPathComponent(pathComponent: string): string

func appendingPathComponent(_ pathComponent: String) -> URL

Returns a URL constructed by appending the given path component to self. > Note: This function performs a file system operation to determine if > the path component is a directory. If so, it will append a trailing > `/`. If you know in advance that the path component is a directory or > not, then use `func appendingPathComponent(_:isDirectory:)`. New code should use ``URL/appending(path:directoryHint:)`` instead of this method. - Parameter pathComponent: The path component to add.

appendingPathExtension

appendingPathExtension(pathExtension: string): string

func appendingPathExtension(_ pathExtension: String) -> URL

Returns a URL constructed by appending the given path extension to self. If the URL has an empty path (e.g., `http://www.example.com`), then this function will return the URL unchanged. Certain special characters (for example, Unicode Right-To-Left marks) cannot be used as path extensions. If any of those are contained in `pathExtension`, the function will return the URL unchanged. - parameter pathExtension: The extension to append.

deleteLastPathComponent

deleteLastPathComponent(): void

mutating func deleteLastPathComponent()

Returns a URL constructed by removing the last path component of self. This function may either remove a path component or append `/..`. If the URL has an empty path (e.g., `http://www.example.com`), then this function will do nothing.

resolvingSymlinksInPath

resolvingSymlinksInPath(): string

func resolvingSymlinksInPath() -> URL

Resolves any symlinks in the path of a file URL. If the `isFileURL` is false, this method returns `self`.

checkResourceIsReachable

checkResourceIsReachable(): boolean

func checkResourceIsReachable() throws -> Bool

Returns whether the URL's resource exists and is reachable. This method synchronously checks if the resource's backing store is reachable. Checking reachability is appropriate when making decisions that do not require other immediate operations on the resource, e.g. periodic maintenance of UI state that depends on the existence of a specific document. When performing operations such as opening a file or copying resource properties, it is more efficient to simply try the operation and handle failures. This method is currently applicable only to URLs for file system resources. For other URL types, `false` is returned.

customPlaygroundQuickLook

get customPlaygroundQuickLook(): SDKHandle

var customPlaygroundQuickLook: PlaygroundQuickLook { get }

A playground quicklook for the URL.

deletingLastPathComponent

deletingLastPathComponent(): string

func deletingLastPathComponent() -> URL

Returns a URL constructed by removing the last path component of self. This function may either remove a path component or append `/..`. If the URL has an empty path that is not resolved against a base URL (e.g., `http://www.example.com`), then this function will return the URL unchanged.

removeCachedResourceValue

removeCachedResourceValue(key: URLResourceKey): void

mutating func removeCachedResourceValue(forKey key: URLResourceKey)

Removes the cached resource value identified by a given resource value key from the URL object. Removing a cached resource value may remove other cached resource values because some resource values are cached as a set of values, and because some resource values depend on other resource values (temporary resource values have no dependencies). This method is currently applicable only to URLs for file system resources.

setTemporaryResourceValue

setTemporaryResourceValue(value: SDKHandle, key: URLResourceKey): void

@preconcurrency mutating func setTemporaryResourceValue(_ value: any Sendable, forKey key: URLResourceKey)

Sets a temporary resource value on the URL object. Temporary resource values are for client use. Temporary resource values exist only in memory and are never written to the resource's backing store. Once set, a temporary resource value can be copied from the URL object with `func resourceValues(forKeys:)`. The values are stored in the loosely-typed `allValues` dictionary property. To remove a temporary resource value from the URL object, use `func removeCachedResourceValue(forKey:)`. Care should be taken to ensure the key that identifies a temporary resource value is unique and does not conflict with system defined keys (using reverse domain name notation in your temporary resource value keys is recommended). This method is currently applicable only to URLs for file system resources.

promisedItemResourceValues

promisedItemResourceValues(keys: Array<URLResourceKey>): URLResourceValues

func promisedItemResourceValues(forKeys keys: Set<URLResourceKey>) throws -> URLResourceValues

Get resource values from URLs of 'promised' items. A promised item is not guaranteed to have its contents in the file system until you use `FileCoordinator` to perform a coordinated read on its URL, which causes the contents to be downloaded or otherwise generated. Promised item URLs are returned by various APIs, including currently: NSMetadataQueryUbiquitousDataScope NSMetadataQueryUbiquitousDocumentsScope A `FilePresenter` presenting the contents of the directory located by -URLForUbiquitousContainerIdentifier: or a subdirectory thereof The following methods behave identically to their similarly named methods above (`func resourceValues(forKeys:)`, etc.), except that they allow you to get resource values and check for presence regardless of whether the promised item's contents currently exist at the URL. You must use these APIs instead of the normal URL resource value APIs if and only if any of the following are true: You are using a URL that you know came directly from one of the above APIs You are inside the accessor block of a coordinated read or write that used NSFileCoordinatorReadingImmediatelyAvailableMetadataOnly, NSFileCoordinatorWritingForDeleting, NSFileCoordinatorWritingForMoving, or NSFileCoordinatorWritingContentIndependentMetadataOnly Most of the URL resource value keys will work with these APIs. However, there are some that are tied to the item's contents that will not work, such as `contentAccessDateKey` or `generationIdentifierKey`. If one of these keys is used, the method will return a `URLResourceValues` value, but the value for that property will be nil.

applicationSupportDirectory

static get applicationSupportDirectory(): string

static var applicationSupportDirectory: URL { get }

The application support directory for the current user. Complexity: O(n) where n is the number of significant directories specified by `FileManager.SearchPathDirectory`

checkPromisedItemIsReachable

checkPromisedItemIsReachable(): boolean

func checkPromisedItemIsReachable() throws -> Bool

Returns whether the promised item URL's resource exists and is reachable. This method synchronously checks if the resource's backing store is reachable. Checking reachability is appropriate when making decisions that do not require other immediate operations on the resource, e.g. periodic maintenance of UI state that depends on the existence of a specific document. When performing operations such as opening a file or copying resource properties, it is more efficient to simply try the operation and handle failures. This method is currently applicable only to URLs for file system resources. For other URL types, `false` is returned.

removeAllCachedResourceValues

removeAllCachedResourceValues(): void

mutating func removeAllCachedResourceValues()

Removes all cached resource values and all temporary resource values from the URL object. This method is currently applicable only to URLs for file system resources.

init

static initFileReferenceLiteralResourceName(name: string): string

init(fileReferenceLiteralResourceName name: String)

Creates a URL from a playground file literal. - Parameter name: The playground file literal name, as a string.

withUnsafeFileSystemRepresentation

withUnsafeFileSystemRepresentation(block: ((arg0: (SDKHandle) | null) => unknown)): unknown

func withUnsafeFileSystemRepresentation<ResultType>(_ block: (UnsafePointer<Int8>?) throws -> ResultType) rethrows -> ResultType

Passes the URL's path in file system representation to `block`. File system representation is a null-terminated C string with canonical UTF-8 encoding. - note: The pointer is not valid outside the context of the block.

init

static initFileURLWithFileSystemRepresentationIsDirectoryRelativeTo(path: SDKHandle, isDirectory: boolean, base?: (string) | null): string

init(fileURLWithFileSystemRepresentation path: UnsafePointer<Int8>, isDirectory: Bool, relativeTo base: URL?)

Initializes a newly created URL referencing the local file or directory at the file system representation of the path. File system representation is a null-terminated C string with canonical UTF-8 encoding.

stopAccessingSecurityScopedResource

stopAccessingSecurityScopedResource(): void

func stopAccessingSecurityScopedResource()

Revokes the access granted to the url by a prior successful call to startAccessingSecurityScopedResource.

startAccessingSecurityScopedResource

startAccessingSecurityScopedResource(): boolean

func startAccessingSecurityScopedResource() -> Bool

Given an NSURL created by resolving a bookmark data created with security scope, make the resource referenced by the url accessible to the process. When access to this resource is no longer needed the client must call stopAccessingSecurityScopedResource. Each call to startAccessingSecurityScopedResource must be balanced with a call to stopAccessingSecurityScopedResource (Note: this is not reference counted).

init

static initForInAppropriateForCreate(directory: FileManager_SearchPathDirectory, domain: FileManager_SearchPathDomainMask, url?: (string) | null, shouldCreate?: boolean): string

init(for directory: FileManager.SearchPathDirectory, in domain: FileManager.SearchPathDomainMask, appropriateFor url: URL? = nil, create shouldCreate: Bool = false) throws

Creates a file URL for a common directory in a domain. - Parameters: - directory: The search path for the commonly used directory. - domain: The file system domain to search. Specify only one domain for this parameter. - url: The file URL for determining the location of the returned URL. Only the volume of this parameter is relevant. - shouldCreate: A Boolean value that indicates whether the initializer creates the directory if it doesn't already exist.

host

hostPercentEncoded(percentEncoded?: boolean): (string) | null

func host(percentEncoded: Bool = true) -> String?

Returns the host component of the URL, optionally removing any percent-encoding. The system doesn't allow certain characters in the URL host component, so ``URL`` percent-encodes those characters to create a valid URL. Calling this function with `percentEncoded = false` removes any percent-encoding and returns the unencoded host. If the URL doesn't contain a host component according to [RFC 3986](https://www.ietf.org/rfc/rfc3986.txt), this function returns `nil`. - Parameter percentEncoded: Whether the host should be percent encoded, defaults to `true`. - Returns: The host component of the URL.

host

get host(): (string) | null

var host: String? { get }

The host component of a URL if the URL conforms to RFC 3986; otherwise, nil. > Note: This function resolves against the base `URL`. New code should use ``URL/host(percentEncoded:)`` instead of this property.

path

pathPercentEncoded(percentEncoded?: boolean): string

func path(percentEncoded: Bool = true) -> String

Returns the path component of the URL, optionally removing any percent-encoding. The system doesn't allow certain characters in the URL path component, so ``URL`` percent-encodes those characters to create a valid URL. Calling this function with `percentEncoded = false` removes any percent-encoding and returns the unencoded path. If the URL's path component is empty, this method returns an empty string. - Note: This function resolves against the base `URL`. - Parameter percentEncoded: Whether the path should be percent encoded, defaults to `true`. - Returns: The path component of the URL.

path

get path(): string

var path: String { get }

The path component of the URL if the URL conforms to RFC 3986; otherwise, an empty string. > Note: This function resolves against the base `URL`. New code should use ``URL/path(percentEncoded:)`` instead of this property. - Returns: The path, or an empty string if the URL has an empty path.

port

get port(): (number) | null

var port: Int? { get }

The port component of the URL if the URL conforms to RFC 3986; otherwise, nil. > Note: This function resolves against the base `URL`.

user

userPercentEncoded(percentEncoded?: boolean): (string) | null

func user(percentEncoded: Bool = true) -> String?

Returns the user component of the URL, optionally removing any percent-encoding. The system doesn't allow certain characters in the URL user component, so ``URL`` percent-encodes those characters to create a valid URL. Calling this function with `percentEncoded = false` removes any percent-encoding and returns the unencoded user. If the URL doesn't contain a user component according to [RFC 3986](https://www.ietf.org/rfc/rfc3986.txt), this function returns `nil`. - Parameter percentEncoded: Whether the user should be percent encoded, defaults to `true`. - Returns: The user component of the URL.

user

get user(): (string) | null

var user: String? { get }

The user component of the URL if the URL conforms to RFC 3986; otherwise, nil. > Note: This function resolves against the base `URL`. New code should use ``URL/user(percentEncoded:)`` instead of this property.

lines

get lines(): AsyncLineSequence<URL_AsyncBytes>

var lines: AsyncLineSequence<URL.AsyncBytes> { get }

The URL's resource data, as an asynchronous sequence of lines of text. Use this property with Swift's `for`-`await`-`in` syntax, to read the contents of a URL line-by-line. To wait for the entire resource to load, use the ``URLSession`` method ``URLSession/data(from:delegate:)`` with the `await` keyword.

query

queryPercentEncoded(percentEncoded?: boolean): (string) | null

func query(percentEncoded: Bool = true) -> String?

Returns the query component of the URL, optionally removing any percent-encoding. The system doesn't allow certain characters in the URL query component, so ``URL`` percent-encodes those characters to create a valid URL. Calling this function with `percentEncoded = false` removes any percent-encoding and returns the unencoded query. If the URL doesn't contain a query component according to [RFC 3986](https://www.ietf.org/rfc/rfc3986.txt), this function returns `nil`. - Parameter percentEncoded: Whether the query should be percent encoded, defaults to `true`. - Returns: The query component of the URL.

query

get query(): (string) | null

var query: String? { get }

The query of the URL if the URL conforms to RFC 3986; otherwise, nil. > Note: This function resolves against the base `URL`. New code should use ``URL/query(percentEncoded:)`` instead of this property.

append

appendQueryItems(queryItems: Array<URLQueryItem>): void

mutating func append(queryItems: [URLQueryItem])

Appends a list of `URLQueryItem` to the receiver. - Parameter queryItems: A list of `URLQueryItem` to append to the receiver.

append

appendPathDirectoryHint(path: string, directoryHint?: URL_DirectoryHint): void

mutating func append<S>(path: S, directoryHint: URL.DirectoryHint = .inferFromPath) where S : StringProtocol

Appends a path to the URL, with a hint for handling directory awareness. This method doesn't percent-encode any path separators (`/`) in the path component before appending the component to the path. If you want this encoding, use ``URL/append(component:directoryHint:)`` instead. - Parameters: - path: The path to add. - directoryHint: A hint to whether this URL will point to a directory. Defaults to ``URL/DirectoryHint/inferFromPath``.

append

appendComponentDirectoryHint(component: string, directoryHint?: URL_DirectoryHint): void

mutating func append<S>(component: S, directoryHint: URL.DirectoryHint = .inferFromPath) where S : StringProtocol

Appends a path component to the receiver. The path component is first percent-encoded before being appended to the receiver. - Parameters: - component: A path component to append to the receiver. - directoryHint: A hint to whether this URL will point to a directory.

scheme

get scheme(): (string) | null

var scheme: String? { get }

The scheme of the URL.

init

static initStringRelativeTo(string: string, url?: (string) | null): (string) | null

init?(string: String, relativeTo url: URL?)

Creates a URL instance from the provided string, relative to another URL. - Parameters: - string: A relative URL location. - url: A URL that provides a base location that the string extends. > Important: For apps linked on or after iOS 17 and aligned OS versions, > ``URL`` parsing has updated from the obsolete RFC 1738/1808 parsing to > the same [RFC 3986](https://www.ietf.org/rfc/rfc3986.txt) parsing as > ``URLComponents``. This unifies the parsing behaviors of the `URL` and > `URLComponents` APIs. Now, `URL` automatically percent- and > IDNA-encodes invalid characters to help create a valid URL. This initializer returns `nil` if the string doesn't represent a valid URL even after encoding invalid characters. To check if a URL string is strictly valid according to the RFC, use the new ``URL/init(string:encodingInvalidCharacters:)`` initializer and pass `encodingInvalidCharacters: false`. This leaves all characters as they are and returns `nil` if the URL string is explicitly invalid.

init

static initStringEncodingInvalidCharacters(string: string, encodingInvalidCharacters: boolean): (string) | null

init?(string: String, encodingInvalidCharacters: Bool)

Creates a URL instance from the provided string, optionally IDNA- and percent-encoding any invalid characters. - Parameters: - string: A URL location. - encodingInvalidCharacters: A Boolean value that indicates whether the initializer attempts to encode any invalid characters in `string`. If `encodingInvalidCharacters` is `true`, this initializer tries to encode the string to create a valid URL. If the URL string is still invalid after encoding, the initializer returns `nil`. If `encodingInvalidCharacters` is `false`, and the URL string is invalid according to RFC 3986, `nil` is returned.

init

static initString(string: string): (string) | null

init?(string: String)

Creates a URL instance from the provided string. - Parameter string: A URL location. > Important: For apps linked on or after iOS 17 and aligned OS versions, > ``URL`` parsing has updated from the obsolete RFC 1738/1808 parsing to > the same [RFC 3986](https://www.ietf.org/rfc/rfc3986.txt) parsing as > ``URLComponents``. This unifies the parsing behaviors of the `URL` and > `URLComponents` APIs. Now, `URL` automatically percent- and > IDNA-encodes invalid characters to help create a valid URL. This initializer returns `nil` if the string doesn't represent a valid URL even after encoding invalid characters. To check if a URL string is strictly valid according to the RFC, use the new ``URL/init(string:encodingInvalidCharacters:)`` initializer and pass `encodingInvalidCharacters: false`. This leaves all characters as they are and returns `nil` if the URL string is explicitly invalid.

init

static initFilePathDirectoryHintRelativeTo(path: string, directoryHint?: URL_DirectoryHint, base?: (string) | null): string

init(filePath path: String, directoryHint: URL.DirectoryHint = .inferFromPath, relativeTo base: URL? = nil)

Creates a file URL that references a path you specify as a string. - Parameters: - path: The location in the file system, as a string. - directoryHint: A hint to the initializer to indicate whether the path is a directory, or to instruct the initializer to make this determination. - base: A URL that provides a file system location that the path extends. If an empty string is used for the path, the system interprets it as ".".

init

static initFilePathDirectoryHint(path: _System_FilePath, directoryHint?: URL_DirectoryHint): (string) | null

init?(filePath path: FilePath, directoryHint: URL.DirectoryHint = .inferFromPath)

Creates a URL from a file path by by copying and validating its UTF-8 contents. This initializer does not try to repair ill-formed UTF-8 code unit sequences. If any are found, the result of the initializer is `nil`.

fragment

fragmentPercentEncoded(percentEncoded?: boolean): (string) | null

func fragment(percentEncoded: Bool = true) -> String?

Returns the fragment component of the URL, optionally removing any percent-encoding. The system doesn't allow certain characters in the URL fragment component, so ``URL`` percent-encodes those characters to create a valid URL. Calling this function with `percentEncoded = false` removes any percent-encoding and returns the unencoded fragment. If the URL doesn't contain a fragment component according to [RFC 3986](https://www.ietf.org/rfc/rfc3986.txt), this function returns `nil`. - Parameter percentEncoded: Whether the fragment should be percent encoded, defaults to `true`. - Returns: The fragment component of the URL.

fragment

get fragment(): (string) | null

var fragment: String? { get }

The fragment component of the URL if the URL conforms to RFC 3986; otherwise, nil. > Note: This function resolves against the base `URL`. New code should use ``URL/fragment(percentEncoded:)`` instead of this property.

password

passwordPercentEncoded(percentEncoded?: boolean): (string) | null

func password(percentEncoded: Bool = true) -> String?

Returns the password component of the URL, optionally removing any percent-encoding. The system doesn't allow certain characters in the URL password component, so ``URL`` percent-encodes those characters to create a valid URL. Calling this function with `percentEncoded = false` removes any percent-encoding and returns the unencoded password. If the URL doesn't contain a password component according to [RFC 3986](https://www.ietf.org/rfc/rfc3986.txt), this function returns `nil`. - Parameter percentEncoded: Whether the password should be percent encoded, defaults to `true`. - Returns: The password component of the URL.

password

get password(): (string) | null

var password: String? { get }

The password component of the URL if the URL conforms to RFC 3986; otherwise, nil. > Note: This function resolves against the base `URL`. New code should use ``URL/password(percentEncoded:)`` instead of this property.

init

static initResource(resource: URLResource): (string) | null

init?(resource: URLResource)

Creates a URL from a resource. Use this initializer to resolve `URLResource` instances, possibly received from other processes, into `URL` instances. - Parameter resource: A `URLResource` that provides a reference to a resource in a given bundle.

init

static initTemplateVariables(template: URL_Template, variables: NativeMap<URL_Template_VariableName, URL_Template_Value>): (string) | null

init?(template: URL.Template, variables: [URL.Template.VariableName : URL.Template.Value])

Creates a new `URL` by expanding the RFC 6570 template and variables. This will fail if variable expansion does not produce a valid, well-formed URL. All text will be converted to NFC (Unicode Normalization Form C) and UTF-8 before being percent-encoded if needed. - Parameters: - template: The RFC 6570 template to be expanded. - variables: Variables to expand in the template.

appending

appendingQueryItems(queryItems: Array<URLQueryItem>): string

func appending(queryItems: [URLQueryItem]) -> URL

Returns a URL constructed by appending the given list of `URLQueryItem` to self. - Parameter queryItems: A list of `URLQueryItem` to append to the receiver.

appending

appendingPathDirectoryHint(path: string, directoryHint?: URL_DirectoryHint): string

func appending<S>(path: S, directoryHint: URL.DirectoryHint = .inferFromPath) -> URL where S : StringProtocol

Returns a URL constructed by appending the given path to self. This method doesn't percent-encode any path separators (`/`) in the path component before appending the component to the path. If you want this encoding, use ``URL/appending(component:directoryHint:)`` instead. - Parameters: - path: The path to add. - directoryHint: A hint to whether this URL will point to a directory.

appending

appendingComponentDirectoryHint(component: string, directoryHint?: URL_DirectoryHint): string

func appending<S>(component: S, directoryHint: URL.DirectoryHint = .inferFromPath) -> URL where S : StringProtocol

Returns a URL constructed by appending the given path component to self. The path component is first percent-encoded before being appended to the receiver. - Parameters: - component: A path component to append to the receiver. - directoryHint: A hint to whether this URL will point to a directory. - Returns: The new URL

formatted

formatted(): string

func formatted() -> String

Formats the URL using a default format style. Use this method to create a string representation of a URL using the default ``URL/FormatStyle`` configuration. The default style creates a string with the scheme, host, and path, but not the port or query. To customize formatting of the URL, use ``URL/formatted(_:)``, passing in a customized ``FormatStyle``. - Returns: A string representation of the URL, formatted according to the default format style.

init

static initIsDirectory(path: _System_FilePath, isDirectory: boolean): (string) | null

init?(_ path: FilePath, isDirectory: Bool)

Creates a URL from a file path by by copying and validating its UTF-8 contents. This initializer does not try to repair ill-formed UTF-8 code unit sequences. If any are found, the result of the initializer is `nil`.

init

static init(path: _System_FilePath): (string) | null

init?(_ path: FilePath)

Creates a URL from a file path by by copying and validating its UTF-8 contents. This initializer does not try to repair ill-formed UTF-8 code unit sequences. If any are found, the result of the initializer is `nil`.