Swift - encoder l'URL

Swift 3

Dans Swift 3 il est addingPercentEncoding

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

De sortie:

test%2Ftest

Swift 1

Dans iOS 7 et ci-dessus, il est stringByAddingPercentEncodingWithAllowedCharacters

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

De sortie:

test%2Ftest

Suivantes sont utiles (inversé) jeux de caractères:

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

Si vous voulez un jeu de caractères différent pour être échappé de créer un jeu:

Exemple avec ajout de caractère"=":

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

De sortie:

test%2Ftest%3D42

Exemple, pour vérifier les caractères ascii sont pas dans le jeu:

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)\'")
}

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 trouver de l'aide .alphanumerics jeu de caractères de l'option la plus facile:

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

Aide de l'un des Jeux de Caractères standard de Codage d'URL (comme URLQueryAllowedCharacterSet ou URLHostAllowedCharacterSet) ne fonctionnera pas, parce qu'ils n'excluent pas = ou & caractères.

Note qu'en utilisant .alphanumerics il va encoder des caractères qui ne doivent pas être codés (comme -, ., _ ou ~ -- voir 2.3. Sans réserve caractères dans la RFC 3986). - Je trouver de l'aide .alphanumerics plus simple que la construction d'un jeu de caractères personnalisée et n'ont pas l'esprit de certains, d'autres caractères à encoder. Si cela vous ennuie, la construction d'un jeu de caractères personnalisée, comme il est décrit dans Comment pour cent encoder 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: La encoded paramètre est la force déballé. Pour les invalides de chaîne unicode, il peut se bloquer. Voir Pourquoi la valeur de retour de la Chaîne.addingPercentEncoding (optionnelle)?. Au lieu de la force d'ôter encoded! vous pouvez utiliser encoded ?? "" ou de l'utilisation if let encoded = ....

Swift 4 (non testé - s'il vous plaît commentaire si ça fonctionne ou pas. 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 la correction de l'url de la requête de la clé et les valeurs de paramètre)

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"

C'est une version plus courte de Bryan Chen réponse. Je suppose que urlQueryAllowed est de permettre les caractères de contrôle par le biais de ce qui est bien, sauf s'ils font partie de la clé ou de la valeur dans votre chaîne de requête à quel point ils doivent être échappés.

Avait besoin de moi-même, j'ai donc écrit une Chaîne d'extension qui à la fois permet l'Encodage des chaînes, ainsi que le plus commun de l'objectif final, la conversion d'un paramètre dictionnaire en "GET" style de Paramètres d'URL:

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
    }
}

Profitez-en!

Swift 4.2

Un rapide d'une solution en ligne. Remplacer originalString avec la Chaîne que vous souhaitez encoder.

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

Espace De Jeu En Ligne De La Démo

C'est de travailler pour moi en Swift 5. Le cas d'utilisation est de prendre une URL dans le presse-papiers ou similaires, qui peuvent déjà avoir des caractères d'échappement, mais qui contient également des caractères Unicode qui pourrait provoquer des URLComponents ou URL(string:) à l'échec.

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

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, étendre String avec 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

Noter que les deux %20 et + espacement sont préservés, des caractères Unicode codés, le %20 dans l'original urlText n'est pas double codé, et l'ancre (fragment, ou #) reste.

Edit: Maintenant la vérification de validité de chaque composant.