Swift - encoder l'URL

Si j'encode une chaîne comme celle-ci:

var escapedString = originalString.stringByAddingPercentEscapesUsingEncoding(NSUTF8StringEncoding)

il n'échappe pas aux barres obliques /.

J'ai recherché et trouvé ce code Objective C:

NSString *encodedString = (NSString *)CFURLCreateStringByAddingPercentEscapes(
                        NULL,
                        (CFStringRef)unencodedString,
                        NULL,
                        (CFStringRef)@"!*'();:@&=+$,/?%#[]",
                        kCFStringEncodingUTF8 );

Existe-t-il un moyen plus simple de coder une URL et sinon, comment l'écrire dans Swift?

Swift 3

Dans Swift 3, il y a addingPercentEncoding

let originalString = "test/test"
let escapedString = originalString.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed)
print(escapedString!)

Production:

test% 2Ftest

Swift 1

Dans iOS 7 et supérieur, il y a stringByAddingPercentEncodingWithAllowedCharacters

var originalString = "test/test"
var escapedString = originalString.stringByAddingPercentEncodingWithAllowedCharacters(.URLHostAllowedCharacterSet())
println("escapedString: \(escapedString)")

Production:

test% 2Ftest

Les jeux de caractères suivants sont utiles (inversés):

URLFragmentAllowedCharacterSet  "#%<>[\]^`{|}
URLHostAllowedCharacterSet      "#%/<>?@\^`{|}
URLPasswordAllowedCharacterSet  "#%/:<>?@[\]^`{|}
URLPathAllowedCharacterSet      "#%;<>?[\]^`{|}
URLQueryAllowedCharacterSet     "#%<>[\]^`{|}
URLUserAllowedCharacterSet      "#%/:<>?@[\]^`

Si vous souhaitez échapper un autre jeu de caractères, créez un jeu:
Exemple avec un caractère "=" ajouté:

var originalString = "test/test=42"
var customAllowedSet =  NSCharacterSet(charactersInString:"=\"#%/<>?@\\^`{|}").invertedSet
var escapedString = originalString.stringByAddingPercentEncodingWithAllowedCharacters(customAllowedSet)
println("escapedString: \(escapedString)")

Production:

test% 2Ftest% 3D42

Exemple de vérification des caractères ascii absents de l'ensemble:

func printCharactersInSet(set: NSCharacterSet) {
    var characters = ""
    let iSet = set.invertedSet
    for i: UInt32 in 32..<127 {
        let c = Character(UnicodeScalar(i))
        if iSet.longCharacterIsMember(i) {
            characters = characters + String(c)
        }
    }
    print("characters not in set: \'\(characters)\'")
}

Vous pouvez utiliser URLComponents pour éviter d'avoir à encoder manuellement en pourcentage votre chaîne de requête:

let scheme = "https"
let host = "www.google.com"
let path = "/search"
let queryItem = URLQueryItem(name: "q", value: "Formula One")


var urlComponents = URLComponents()
urlComponents.scheme = scheme
urlComponents.host = host
urlComponents.path = path
urlComponents.queryItems = [queryItem]

if let url = urlComponents.url {
    print(url)   // "https://www.google.com/search?q=Formula%20One"
}

extension URLComponents {
    init(scheme: String = "https",
         host: String = "www.google.com",
         path: String = "/search",
         queryItems: [URLQueryItem]) {
        self.init()
        self.scheme = scheme
        self.host = host
        self.path = path
        self.queryItems = queryItems
    }
}

let query = "Formula One"
if let url = URLComponents(queryItems: [URLQueryItem(name: "q", value: query)]).url {
    print(url)  // https://www.google.com/search?q=Formula%20One
}

Swift 3:

let originalString = "http://www.ihtc.cc?name=htc&title=iOS开发工程师"

1. encodingQuery:

let escapedString = originalString.addingPercentEncoding(withAllowedCharacters:NSCharacterSet.urlQueryAllowed)

résultat:

"http://www.ihtc.cc?name=htc&title=iOS%E5%BC%80%E5%8F%91%E5%B7%A5%E7%A8%8B%E5%B8%88" 

2. encodingURL:

let escapedString = originalString.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed)

résultat:

"http:%2F%2Fwww.ihtc.cc%3Fname=htc&title=iOS%E5%BC%80%E5%8F%91%E5%B7%A5%E7%A8%8B%E5%B8%88"

Swift 3:

let allowedCharacterSet = (CharacterSet(charactersIn: "!*'();:@&=+$,/?%#[] ").inverted)

if let escapedString = originalString.addingPercentEncoding(withAllowedCharacters: allowedCharacterSet) {
//do something with escaped string
}

Swift 4

Pour encoder un paramètre dans l'URL, je trouve en utilisant le .alphanumericsjeu de caractères l'option la plus simple:

let encoded = parameter.addingPercentEncoding(withAllowedCharacters: .alphanumerics)
let url = "http://www.example.com/?name=\(encoded!)"

L'utilisation de l'un des jeux de caractères standard pour le codage d'URL (comme URLQueryAllowedCharacterSetou URLHostAllowedCharacterSet) ne fonctionnera pas, car ils n'excluent pas =ou les &caractères.

Notez qu'en utilisant .alphanumericsce codent des caractères qui ne ont pas besoin d'être codées (comme -, ., _ou ~- voir 2.3 caractères non réservés. Dans la RFC 3986). Je trouve l'utilisation .alphanumericsplus simple que la construction d'un jeu de caractères personnalisé et cela ne me dérange pas que certains caractères supplémentaires soient encodés. Si cela vous dérange, créez un jeu de caractères personnalisé comme décrit dans Comment coder en pourcentage une chaîne d'URL , comme par exemple:

var allowed = CharacterSet.alphanumerics
allowed.insert(charactersIn: "-._~") // as per RFC 3986
let encoded = parameter.addingPercentEncoding(withAllowedCharacters: allowed)
let url = "http://www.example.com/?name=\(encoded!)"

Avertissement: le encodedparamètre est déplié de force. Pour une chaîne Unicode non valide, elle peut se bloquer. Voir Pourquoi la valeur de retour de String.addingPercentEncoding () est-elle facultative? . Au lieu de déballer de force, encoded!vous pouvez utiliser encoded ?? ""ou utiliser if let encoded = ....

Tout est pareil

var str = CFURLCreateStringByAddingPercentEscapes(
    nil,
    "test/test",
    nil,
    "!*'();:@&=+$,/?%#[]",
    CFStringBuiltInEncodings.UTF8.rawValue
)

// test%2Ftest

Swift 4:

Cela dépend des règles d'encodage suivies par votre serveur.

Apple propose cette méthode de classe, mais elle ne signale pas quel type de protocole RCF elle suit.

var escapedString = originalString.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed)!

En suivant cet outil utile , vous devez garantir le codage de ces caractères pour vos paramètres:

• $ (Signe dollar) devient% 24
• & (Esperluette) devient% 26
• + (Plus) devient% 2B
• , (Virgule) devient% 2C
• : (Deux points) devient% 3A
• ; (Point-virgule) devient% 3B
• = (Égale) devient% 3D
• ? (Point d'interrogation) devient% 3F
• @ (Commercial A / At) devient% 40

En d'autres termes, en parlant d'encodage d'URL, vous devez suivre le protocole RFC 1738 .

Et Swift ne couvre pas l'encodage du caractère + par exemple , mais cela fonctionne bien avec ces trois @:? caractères.

Donc, pour encoder correctement chacun de vos paramètres, l' .urlHostAllowedoption ne suffit pas, vous devez également ajouter les caractères spéciaux comme par exemple:

encodedParameter = parameter.replacingOccurrences(of: "+", with: "%2B")

J'espère que cela aide quelqu'un qui devient fou à rechercher ces informations.

Swift 4 (non testé - veuillez commenter si cela fonctionne ou non. Merci @sumizome pour la suggestion)

var allowedQueryParamAndKey = NSCharacterSet.urlQueryAllowed
allowedQueryParamAndKey.remove(charactersIn: ";/?:@&=+$, ")
paramOrKey.addingPercentEncoding(withAllowedCharacters: allowedQueryParamAndKey)

Swift 3

let allowedQueryParamAndKey =  NSCharacterSet.urlQueryAllowed.remove(charactersIn: ";/?:@&=+$, ")
paramOrKey.addingPercentEncoding(withAllowedCharacters: allowedQueryParamAndKey)

Swift 2.2 (Emprunt de Zaph et correction des valeurs de clé et de paramètre de requête d'URL)

var allowedQueryParamAndKey =  NSCharacterSet(charactersInString: ";/?:@&=+$, ").invertedSet
paramOrKey.stringByAddingPercentEncodingWithAllowedCharacters(allowedQueryParamAndKey)

Exemple:

let paramOrKey = "https://some.website.com/path/to/page.srf?a=1&b=2#top"
paramOrKey.addingPercentEncoding(withAllowedCharacters: allowedQueryParamAndKey)
// produces:
"https%3A%2F%2Fsome.website.com%2Fpath%2Fto%2Fpage.srf%3Fa%3D1%26b%3D2%23top"

Ceci est une version courte de la réponse de Bryan Chen. Je suppose que cela urlQueryAllowedpermet aux caractères de contrôle de passer, à moins qu'ils ne fassent partie de la clé ou de la valeur de votre chaîne de requête à quel point ils doivent être échappés.

Swift 4.2

Une solution rapide en ligne. Remplacez originalStringpar la chaîne que vous souhaitez encoder.

var encodedString = originalString.addingPercentEncoding(withAllowedCharacters: CharacterSet(charactersIn: "!*'();:@&=+$,/?%#[]{} ").inverted)

Démo de Playground en ligne

J'en avais besoin moi-même, j'ai donc écrit une extension de chaîne qui permet à la fois les chaînes URLEncoding, ainsi que l'objectif final le plus courant, la conversion d'un dictionnaire de paramètres en paramètres d'URL de style "GET":

extension String {
    func URLEncodedString() -> String? {
        var escapedString = self.addingPercentEncoding(withAllowedCharacters: .urlHostAllowed)
        return escapedString
    }
    static func queryStringFromParameters(parameters: Dictionary<String,String>) -> String? {
        if (parameters.count == 0)
        {
            return nil
        }
        var queryString : String? = nil
        for (key, value) in parameters {
            if let encodedKey = key.URLEncodedString() {
                if let encodedValue = value.URLEncodedString() {
                    if queryString == nil
                    {
                        queryString = "?"
                    }
                    else
                    {
                        queryString! += "&"
                    }
                    queryString! += encodedKey + "=" + encodedValue
                }
            }
        }
        return queryString
    }
}

Prendre plaisir!

Celui-ci fonctionne pour moi.

func stringByAddingPercentEncodingForFormData(plusForSpace: Bool=false) -> String? {

    let unreserved = "*-._"
    let allowed = NSMutableCharacterSet.alphanumericCharacterSet()
    allowed.addCharactersInString(unreserved)

    if plusForSpace {
        allowed.addCharactersInString(" ")
    }

    var encoded = stringByAddingPercentEncodingWithAllowedCharacters(allowed)

    if plusForSpace {
        encoded = encoded?.stringByReplacingOccurrencesOfString(" ", withString: "+")
    }
    return encoded
}

J'ai trouvé la fonction ci-dessus à partir de ce lien: http://useyourloaf.com/blog/how-to-percent-encode-a-url-string/ .

let Url = URL(string: urlString.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) ?? "")

SWIFT 4.2

Parfois, cela s'est produit simplement parce qu'il y a de l'espace dans la limace OU l'absence de codage d'URL pour les paramètres passant par l'URL de l'API.

let myString = self.slugValue
                let csCopy = CharacterSet(bitmapRepresentation: CharacterSet.urlPathAllowed.bitmapRepresentation)
                let escapedString = myString!.addingPercentEncoding(withAllowedCharacters: csCopy)!
                //always "info:hello%20world"
                print(escapedString)

REMARQUE: N'oubliez pas d'explorer bitmapRepresentation.

Cela fonctionne pour moi dans Swift 5 . Le cas d'utilisation prend une URL du presse-papiers ou similaire qui peut déjà avoir des caractères d'échappement mais qui contient également des caractères Unicode qui pourraient provoquer URLComponentsouURL(string:) échouer.

Tout d'abord, créez un jeu de caractères qui comprend tous les caractères autorisés par l'URL:

extension CharacterSet {

    /// Characters valid in at least one part of a URL.
    ///
    /// These characters are not allowed in ALL parts of a URL; each part has different requirements. This set is useful for checking for Unicode characters that need to be percent encoded before performing a validity check on individual URL components.
    static var urlAllowedCharacters: CharacterSet {
        // Start by including hash, which isn't in any set
        var characters = CharacterSet(charactersIn: "#")
        // All URL-legal characters
        characters.formUnion(.urlUserAllowed)
        characters.formUnion(.urlPasswordAllowed)
        characters.formUnion(.urlHostAllowed)
        characters.formUnion(.urlPathAllowed)
        characters.formUnion(.urlQueryAllowed)
        characters.formUnion(.urlFragmentAllowed)

        return characters
    }
}

Ensuite, étendez Stringavec une méthode pour encoder les URL:

extension String {

    /// Converts a string to a percent-encoded URL, including Unicode characters.
    ///
    /// - Returns: An encoded URL if all steps succeed, otherwise nil.
    func encodedUrl() -> URL? {        
        // Remove preexisting encoding,
        guard let decodedString = self.removingPercentEncoding,
            // encode any Unicode characters so URLComponents doesn't choke,
            let unicodeEncodedString = decodedString.addingPercentEncoding(withAllowedCharacters: .urlAllowedCharacters),
            // break into components to use proper encoding for each part,
            let components = URLComponents(string: unicodeEncodedString),
            // and reencode, to revert decoding while encoding missed characters.
            let percentEncodedUrl = components.url else {
            // Encoding failed
            return nil
        }

        return percentEncodedUrl
    }

}

Qui peut être testé comme:

let urlText = "https://www.example.com/폴더/search?q=123&foo=bar&multi=eggs+and+ham&hangul=한글&spaced=lovely%20spam&illegal=<>#top"
let url = encodedUrl(from: urlText)

Valeur de urlà la fin:https://www.example.com/%ED%8F%B4%EB%8D%94/search?q=123&foo=bar&multi=eggs+and+ham&hangul=%ED%95%9C%EA%B8%80&spaced=lovely%20spam&illegal=%3C%3E#top

Notez que les deux %20et l' +espacement sont préservés, les caractères Unicode sont codés, l' %20original urlTextn'est pas codé en double et l'ancre (fragment ou #) reste.

Edit: vérifie maintenant la validité de chaque composant.

Pour Swift 5 à la chaîne de code de fin

func escape(string: String) -> String {
    let allowedCharacters = string.addingPercentEncoding(withAllowedCharacters: CharacterSet(charactersIn: ":=\"#%/<>?@\\^`{|}").inverted) ?? ""
    return allowedCharacters
}

Comment utiliser ?

let strEncoded = self.escape(string: "http://www.edamam.com/ontologies/edamam.owl#recipe_e2a1b9bf2d996cbd9875b80612ed9aa4")
print("escapedString: \(strEncoded)")

Aucune de ces réponses n'a fonctionné pour moi. Notre application se bloquait lorsqu'une URL contenait des caractères non anglais.

 let unreserved = "-._~/?%$!:"
 let allowed = NSMutableCharacterSet.alphanumeric()
     allowed.addCharacters(in: unreserved)

 let escapedString = urlString.addingPercentEncoding(withAllowedCharacters: allowed as CharacterSet)

En fonction des paramètres de ce que vous essayez de faire, vous pouvez simplement créer votre propre jeu de caractères. Ce qui précède permet les caractères anglais, et-._~/?%$!: