Schnell - URL verschlüsseln

Wenn ich eine Zeichenfolge wie folgt codiere:

var escapedString = originalString.stringByAddingPercentEscapesUsingEncoding(NSUTF8StringEncoding)

es entgeht nicht den Schrägstrichen /.

Ich habe diesen Objective C-Code gesucht und gefunden:

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

Gibt es eine einfachere Möglichkeit, eine URL zu verschlüsseln, und wenn nicht, wie schreibe ich diese in Swift?

Swift 3

In Swift 3 gibt es addingPercentEncoding

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

Ausgabe:

test% 2Ftest

Schnell 1

In iOS 7 und höher gibt es stringByAddingPercentEncodingWithAllowedCharacters

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

Ausgabe:

test% 2Ftest

Die folgenden nützlichen (invertierten) Zeichensätze sind:

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

Wenn Sie möchten, dass ein anderer Zeichensatz maskiert wird, erstellen Sie einen Satz:
Beispiel mit hinzugefügtem "=" - Zeichen:

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

Ausgabe:

test% 2Ftest% 3D42

Beispiel zum Überprüfen von ASCII-Zeichen, die nicht im Satz enthalten sind:

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

Sie können URLComponents verwenden, um zu vermeiden, dass Sie Ihre Abfragezeichenfolge manuell prozentual codieren müssen:

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)

Ergebnis:

"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)

Ergebnis:

"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

Um einen Parameter in einer URL zu codieren, finde ich die Verwendung des .alphanumericsZeichensatzes die einfachste Option:

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

Unter Verwendung einer der Standardzeichensätze für URL - Kodierung (wie URLQueryAllowedCharacterSetoder URLHostAllowedCharacterSet) wird nicht funktionieren, weil sie es nicht tun ausschließen =oder& Zeichen.

Beachten Sie, dass durch die Verwendung .alphanumericses einige Zeichen kodieren, die nicht brauchen codiert werden (wie -, ., _oder ~- siehe 2.3 Unreserved Zeichen. In RFC 3986). Ich finde die Verwendung .alphanumericseinfacher als das Erstellen eines benutzerdefinierten Zeichensatzes und habe nichts dagegen, einige zusätzliche Zeichen zu codieren. Wenn Sie das stört, erstellen Sie einen benutzerdefinierten Zeichensatz, wie unter So codieren Sie eine URL- Zeichenfolge in Prozent beschrieben , wie zum Beispiel:

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!)"

Warnung: Der encodedParameter wird zwangsweise entpackt. Bei ungültigen Unicode-Zeichenfolgen kann es zum Absturz kommen. Siehe Warum ist der Rückgabewert von String.addingPercentEncoding () optional? . Anstatt das Auspacken zu erzwingen encoded!, können Sie es verwenden encoded ?? ""oder verwenden if let encoded = ....

Alles ist gleich

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

// test%2Ftest

Swift 4:

Dies hängt von den Codierungsregeln ab, die von Ihrem Server befolgt werden.

Apple bietet diese Klassenmethode an, meldet jedoch nicht, welcher Art von RCF-Protokoll es folgt.

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

Wenn Sie diesem nützlichen Tool folgen, sollten Sie die Codierung dieser Zeichen für Ihre Parameter garantieren:

• $ (Dollarzeichen) wird zu% 24
• & (Kaufmännisches Und) wird zu% 26
• + (Plus) wird zu% 2B
• , (Komma) wird% 2C
• : (Doppelpunkt) wird% 3A
• ;; (Semikolon) wird zu% 3B
• = (Gleich) wird zu% 3D
• ? (Fragezeichen) wird% 3F
• @ (Commercial A / At) wird zu% 40

Mit anderen Worten, wenn Sie über die URL-Codierung sprechen, sollten Sie das RFC 1738-Protokoll befolgen .

Und Swift behandelt zum Beispiel nicht die Codierung des + Zeichens , aber es funktioniert gut mit diesen drei @ :? Zeichen.

Um jeden Ihrer Parameter korrekt zu codieren, reicht die .urlHostAllowedOption nicht aus. Sie sollten auch die Sonderzeichen hinzufügen, wie zum Beispiel:

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

Hoffe, dies hilft jemandem, der verrückt wird, diese Informationen zu suchen.

Swift 4 (nicht getestet - bitte kommentieren Sie, ob es funktioniert oder nicht. Danke @sumizome für den Vorschlag)

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 (Ausleihen bei Zaph und Korrektur von URL-Abfrageschlüssel- und Parameterwerten)

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

Beispiel:

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"

Dies ist eine kürzere Version von Bryan Chens Antwort. Ich würde vermuten, urlQueryAlloweddass dies die Steuerzeichen zulässt, durch die dies in Ordnung ist, es sei denn, sie sind Teil des Schlüssels oder Werts in Ihrer Abfragezeichenfolge. An diesem Punkt müssen sie maskiert werden.

Swift 4.2

Eine schnelle einzeilige Lösung. Ersetzen Sie originalStringdurch den String, den Sie codieren möchten.

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

Online-Spielplatz-Demo

Ich brauchte das selbst und schrieb eine String-Erweiterung, die sowohl URLEncoding-Strings als auch das häufigere Endziel ermöglicht, ein Parameterwörterbuch in URL-Parameter im "GET" -Stil zu konvertieren:

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

Genießen!

Dieser arbeitet für mich.

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
}

Ich habe die obige Funktion über diesen Link gefunden: http://useyourloaf.com/blog/how-to-percent-encode-a-url-string/ .

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

SWIFT 4.2

Manchmal geschah dies nur, weil im Slug ODER ohne URL-Codierung Platz für Parameter vorhanden ist, die über die API-URL übertragen werden.

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

HINWEIS: Vergessen Sie nicht, etwas zu erkunden bitmapRepresentation.

Das funktioniert bei mir in Swift 5 . Der Anwendungsfall besteht darin, eine URL aus der Zwischenablage oder ähnlichem zu übernehmen, die möglicherweise bereits maskierte Zeichen enthält, aber auch Unicode-Zeichen enthält, die URLComponentsoder verursachen könnenURL(string:) fehlschlagen können.

Erstellen Sie zunächst einen Zeichensatz, der alle URL-zulässigen Zeichen enthält:

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

Erweitern Sie Stringals Nächstes eine Methode zum Codieren von URLs:

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
    }

}

Welches kann getestet werden wie:

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)

Wert von urlam Ende: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

Beachten Sie, dass sowohl der Abstand %20als auch der +Abstand erhalten bleiben, Unicode-Zeichen codiert werden, das %20im Original urlTextnicht doppelt codiert ist und der Anker (Fragment oder #) erhalten bleibt.

Bearbeiten: Überprüfen Sie nun die Gültigkeit jeder Komponente.

Für Swift 5 zur Endcode-Zeichenfolge

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

Wie benutzt man ?

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

Keine dieser Antworten hat bei mir funktioniert. Unsere App stürzte ab, als eine URL nicht englische Zeichen enthielt.

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

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

Abhängig von den Parametern, die Sie ausführen möchten, möchten Sie möglicherweise nur Ihren eigenen Zeichensatz erstellen. Das obige erlaubt englische Zeichen und-._~/?%$!: