Conversion d'URL en chaîne et vice-versa

J'ai donc converti un NSURLen un String. Donc si je printlnressemble à file:///Users/...etc.

Plus tard, je veux que cela revienne comme un NSURLalors j'essaie de le reconvertir comme indiqué ci-dessous, mais je perds deux des barres obliques qui apparaissent dans la version de chaîne ci-dessus, qui à son tour casse le code car le urln'est pas valide.

Pourquoi ma conversion revient-elle à NSURLsupprimer deux barres obliques de la barre oblique que Stringje lui donne, et comment puis-je convertir à nouveau les NSURLtrois barres obliques contenant?

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()est utilisé pour convertir un chemin de fichier simple (par exemple "/ chemin / vers / fichier") en une URL. Votre urlStringest une chaîne URL complète comprenant le schéma, vous devez donc utiliser

let url = NSURL(string: urlstring)

pour le reconvertir en NSURL. Exemple:

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

Dans Swift 4 et Swift 3 , pour convertir une chaîne en URL:

URL(string: String)

ou,

URL.init(string: "yourURLString")

Et pour convertir l'URL en chaîne:

URL.absoluteString

Celui ci-dessous convertit le 'contenu' de l'url en chaîne

String(contentsOf: URL)

Il existe un moyen plus agréable d'obtenir la version chaîne du chemin à partir du NSURL dans Swift:

let path:String = url.path

AVIS : faites attention à l'url, c'est optionalet ça peut l'être nil. Vous pouvez envelopper votre URL dans le devis pour la convertir en chaîne. Vous pouvez le tester dans la cour de récréation.
Mise à jour pour 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 (oubliez NSURL).

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

Pour créer une URL à partir d'une chaîne:

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

Si nous voulons ajouter le nom du fichier. Notez que appendingPathComponent () ajoute automatiquement le pourcentage d'encodage:

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

Lorsque nous voulons avoir String mais sans la partie racine (faites attention que le pourcentage d'encodage est supprimé automatiquement):

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

Si nous voulons conserver la partie racine, nous le faisons (mais attention au pourcentage d'encodage - il n'est pas supprimé):

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

Pour ajouter manuellement le codage en pourcentage d'une chaîne:

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

Pour supprimer le codage en pourcentage:

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

Le codage en pourcentage est important car les URL pour les requêtes réseau en ont besoin, tandis que les URL vers le système de fichiers ne fonctionneront pas toujours - cela dépend de la méthode réelle qui les utilise. La mise en garde ici est qu'ils peuvent être supprimés ou ajoutés automatiquement, il vaut donc mieux déboguer ces conversions avec soin.

Code de version 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"

Et extension pour URL?

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

        return "\(val.path)"
    }
}

 usage:

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

Swift 3 utilisé avec 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
    }

}