Convertir URL a cadena y viceversa

Entonces he convertido un NSURLa String. Entonces, si me printlnparece, file:///Users/...etc.

Más tarde, quiero esto de nuevo como NSURLasí que trato de convertirlo de nuevo como se ve a continuación, pero pierdo dos de las barras diagonales que aparecen en la versión de cadena anterior, que a su vez rompe el código ya urlque no es válido.

¿Por qué mi conversión vuelve a NSURLeliminar dos barras diagonales de la Stringque le doy, y cómo puedo convertir de nuevo a las NSURLtres barras diagonales que contienen?

var urlstring: String = recordingsDictionaryArray[selectedRow]["path"] as String
println("the url string = \(urlstring)")
// looks like file:///Users/........etc
var url = NSURL.fileURLWithPath(urlstring)
println("the url = \(url!)")
// looks like file:/Users/......etc

fileURLWithPath()se utiliza para convertir una ruta de archivo sin formato (por ejemplo, "/ ruta / a / archivo") en una URL. Su urlStringes una cadena URL completa que incluye el esquema, por lo que debe usar

let url = NSURL(string: urlstring)

para volver a convertirlo NSURL. Ejemplo:

let urlstring = "file:///Users/Me/Desktop/Doc.txt"
let url = NSURL(string: urlstring)
println("the url = \(url!)")
// the url = file:///Users/Me/Desktop/Doc.txt

En Swift 4 y Swift 3 , para convertir String a URL:

URL(string: String)

o,

URL.init(string: "yourURLString")

Y para convertir URL a String:

URL.absoluteString

El siguiente convierte los 'contenidos' de la url a cadena

String(contentsOf: URL)

Hay una mejor manera de obtener la versión de cadena de la ruta desde NSURL en Swift:

let path:String = url.path

AVISO : preste atención a la url, es optionaly puede ser nil. Puede ajustar su url en la cita para convertirla en una cadena. Puedes probarlo en el patio de recreo.
Actualización para Swift 5, Xcode 11:

import Foundation

let urlString = "http://ifconfig.me"
// string to url
let url = URL(string: urlString)
//url to string
let string = "\(url)"
// if you want the path without `file` schema
// let string = "\(url.path)"

let url = URL(string: "URLSTRING HERE")
let anyvar =  String(describing: url)

Swift 3 (olvídate de NSURL).

let fileName = "20-01-2017 22:47"
let folderString = "file:///var/mobile/someLongPath"

Para hacer una URL de una cadena:

let folder: URL? = Foundation.URL(string: folderString)
// Optional<URL>
//  ▿ some : file:///var/mobile/someLongPath

Si queremos agregar el nombre del archivo. Tenga en cuenta que appendingPathComponent () agrega el porcentaje de codificación automáticamente:

let folderWithFilename: URL? = folder?.appendingPathComponent(fileName)
// Optional<URL>
//  ▿ some : file:///var/mobile/someLongPath/20-01-2017%2022:47

Cuando queremos tener String pero sin la parte raíz (preste atención a que la codificación porcentual se elimina automáticamente):

let folderWithFilename: String? = folderWithFilename.path
// ▿ Optional<String>
//  - some : "/var/mobile/someLongPath/20-01-2017 22:47"

Si queremos mantener la parte raíz, hacemos esto (pero tenga en cuenta el porcentaje de codificación, no se elimina):

let folderWithFilenameAbsoluteString: String? = folderWithFilenameURL.absoluteString
// ▿ Optional<String>
//  - some : "file:///var/mobile/someLongPath/20-01-2017%2022:47"

Para agregar manualmente el porcentaje de codificación para una cadena:

let folderWithFilenameAndEncoding: String? = folderWithFilename.addingPercentEncoding(withAllowedCharacters: CharacterSet.urlQueryAllowed)
// ▿ Optional<String>
//  - some : "/var/mobile/someLongPath/20-01-2017%2022:47"

Para eliminar el porcentaje de codificación:

let folderWithFilenameAbsoluteStringNoEncodig: String? = folderWithFilenameAbsoluteString.removingPercentEncoding
// ▿ Optional<String>
//  - some : "file:///var/mobile/someLongPath/20-01-2017 22:47"

La codificación porcentual es importante porque las URL para las solicitudes de red las necesitan, mientras que las URL del sistema de archivos no siempre funcionan, depende del método real que las use. La advertencia aquí es que pueden eliminarse o agregarse automáticamente, por lo que es mejor depurar estas conversiones con cuidado.

Código de versión de Swift 3:

let urlString = "file:///Users/Documents/Book/Note.txt"
let pathURL = URL(string: urlString)!
print("the url = " + pathURL.path)

2020 | SWIFT 5.1:

let url = URL(fileURLWithPath: "//Users/Me/Desktop/Doc.txt")

let a = String(describing: url)       // "file:////Users/Me/Desktop/Doc.txt"
let b = "\(url)"                      // "file:////Users/Me/Desktop/Doc.txt"
let c = url.absoluteString            // "file:////Users/Me/Desktop/Doc.txt"
let d = url.path                      // "/Users/Me/Desktop/Doc.txt" 
// BUT value of `d` will be invisible due to debug process, so...
let e = "\(url.path)"                 // "/Users/Me/Desktop/Doc.txt"

Y extensión para URL?

extension Optional where Wrapped == URL {
    func toString() -> String {
        guard let val = self else { return "" }

        return "\(val.path)"
    }
}

 uso:

let str = optionalUrl.toString() // "/Users/Me/Desktop/Doc.txt"
    str = emptyOptionalUrl.toString() // ""

Swift 3 utilizado con UIWebViewDelegate shouldStartLoadWith

  func webView(_ webView: UIWebView, shouldStartLoadWith request: URLRequest, navigationType: UIWebViewNavigationType) -> Bool {

    let urlPath: String = (request.url?.absoluteString)!
    print(urlPath)
    if urlPath.characters.last == "#" {
        return false
    }else{
        return true
    }

}