Wie kann ich decode HTML entities werden in swift?

@akashivskyy die Antwort ist großartig und zeigt, wie Sie nutzen NSAttributedString zum Dekodieren von HTML-entities. Ein möglicher Nachteil
(so sagte er) ist, dass alle HTML-markup wird entfernt, so

<strong> 4 &lt; 5 &amp; 3 &gt; 2</strong>

wird

4 < 5 & 3 > 2

Unter OS X gibt es CFXMLCreateStringByUnescapingEntities() die nicht den job:

let encoded = "<strong> 4 &lt; 5 &amp; 3 &gt; 2 .</strong> Price: 12 &#x20ac;.  &#64; "
let decoded = CFXMLCreateStringByUnescapingEntities(nil, encoded, nil) as String
println(decoded)
// <strong> 4 < 5 & 3 > 2 .</strong> Price: 12 €.  @ 

aber dies ist nicht auf iOS verfügbar.

Hier ist eine Reine Rasche Umsetzung. Es dekodiert die Zeichen-Entitäten
Hinweise, wie < mit einem Wörterbuch, und alle numerischen Zeichen
Personen wie &#64 oder &#x20ac. (Beachten Sie, dass ich nicht alle auflisten
252 HTML-entities explizit.)

Swift 4:

//Mapping from XML/HTML character entity reference to character
//From http://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references
private let characterEntities : [ Substring : Character ] = [
    //XML predefined entities:
    """    : "\"",
    "&"     : "&",
    "'"    : "'",
    "&lt;"      : "<",
    "&gt;"      : ">",

    //HTML character entity references:
    "&nbsp;"    : "\u{00a0}",
    //...
    "&diams;"   : "♦",
]

extension String {

    ///Returns a new string made by replacing in the `String`
    ///all HTML character entity references with the corresponding
    ///character.
    var stringByDecodingHTMLEntities : String {

        //===== Utility functions =====

        //Convert the number in the string to the corresponding
        //Unicode character, e.g.
        //   decodeNumeric("64", 10)   --> "@"
        //   decodeNumeric("20ac", 16) --> "€"
        func decodeNumeric(_ string : Substring, base : Int) -> Character? {
            guard let code = UInt32(string, radix: base),
                let uniScalar = UnicodeScalar(code) else { return nil }
            return Character(uniScalar)
        }

        //Decode the HTML character entity to the corresponding
        //Unicode character, return `nil` for invalid input.
        //    decode("&#64;")    --> "@"
        //    decode("&#x20ac;") --> "€"
        //    decode("&lt;")     --> "<"
        //    decode("&foo;")    --> nil
        func decode(_ entity : Substring) -> Character? {

            if entity.hasPrefix("&#x") || entity.hasPrefix("&#X") {
                return decodeNumeric(entity.dropFirst(3).dropLast(), base: 16)
            } else if entity.hasPrefix("&#") {
                return decodeNumeric(entity.dropFirst(2).dropLast(), base: 10)
            } else {
                return characterEntities[entity]
            }
        }

        //===== Method starts here =====

        var result = ""
        var position = startIndex

        //Find the next '&' and copy the characters preceding it to `result`:
        while let ampRange = self[position...].range(of: "&") {
            result.append(contentsOf: self[position ..< ampRange.lowerBound])
            position = ampRange.lowerBound

            //Find the next ';' and copy everything from '&' to ';' into `entity`
            guard let semiRange = self[position...].range(of: ";") else {
                //No matching ';'.
                break
            }
            let entity = self[position ..< semiRange.upperBound]
            position = semiRange.upperBound

            if let decoded = decode(entity) {
                //Replace by decoded character:
                result.append(decoded)
            } else {
                //Invalid entity, copy verbatim:
                result.append(contentsOf: entity)
            }
        }
        //Copy remaining characters to `result`:
        result.append(contentsOf: self[position...])
        return result
    }
}

Beispiel:

let encoded = "<strong> 4 &lt; 5 &amp; 3 &gt; 2 .</strong> Price: 12 &#x20ac;.  &#64; "
let decoded = encoded.stringByDecodingHTMLEntities
print(decoded)
// <strong> 4 < 5 & 3 > 2 .</strong> Price: 12 €.  @

Swift 3:

//Mapping from XML/HTML character entity reference to character
//From http://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references
private let characterEntities : [ String : Character ] = [
    //XML predefined entities:
    """    : "\"",
    "&"     : "&",
    "'"    : "'",
    "&lt;"      : "<",
    "&gt;"      : ">",

    //HTML character entity references:
    "&nbsp;"    : "\u{00a0}",
    //...
    "&diams;"   : "♦",
]

extension String {

    ///Returns a new string made by replacing in the `String`
    ///all HTML character entity references with the corresponding
    ///character.
    var stringByDecodingHTMLEntities : String {

        //===== Utility functions =====

        //Convert the number in the string to the corresponding
        //Unicode character, e.g.
        //   decodeNumeric("64", 10)   --> "@"
        //   decodeNumeric("20ac", 16) --> "€"
        func decodeNumeric(_ string : String, base : Int) -> Character? {
            guard let code = UInt32(string, radix: base),
                let uniScalar = UnicodeScalar(code) else { return nil }
            return Character(uniScalar)
        }

        //Decode the HTML character entity to the corresponding
        //Unicode character, return `nil` for invalid input.
        //    decode("&#64;")    --> "@"
        //    decode("&#x20ac;") --> "€"
        //    decode("&lt;")     --> "<"
        //    decode("&foo;")    --> nil
        func decode(_ entity : String) -> Character? {

            if entity.hasPrefix("&#x") || entity.hasPrefix("&#X"){
                return decodeNumeric(entity.substring(with: entity.index(entity.startIndex, offsetBy: 3) ..< entity.index(entity.endIndex, offsetBy: -1)), base: 16)
            } else if entity.hasPrefix("&#") {
                return decodeNumeric(entity.substring(with: entity.index(entity.startIndex, offsetBy: 2) ..< entity.index(entity.endIndex, offsetBy: -1)), base: 10)
            } else {
                return characterEntities[entity]
            }
        }

        //===== Method starts here =====

        var result = ""
        var position = startIndex

        //Find the next '&' and copy the characters preceding it to `result`:
        while let ampRange = self.range(of: "&", range: position ..< endIndex) {
            result.append(self[position ..< ampRange.lowerBound])
            position = ampRange.lowerBound

            //Find the next ';' and copy everything from '&' to ';' into `entity`
            if let semiRange = self.range(of: ";", range: position ..< endIndex) {
                let entity = self[position ..< semiRange.upperBound]
                position = semiRange.upperBound

                if let decoded = decode(entity) {
                    //Replace by decoded character:
                    result.append(decoded)
                } else {
                    //Invalid entity, copy verbatim:
                    result.append(entity)
                }
            } else {
                //No matching ';'.
                break
            }
        }
        //Copy remaining characters to `result`:
        result.append(self[position ..< endIndex])
        return result
    }
}

Swift 2:

//Mapping from XML/HTML character entity reference to character
//From http://en.wikipedia.org/wiki/List_of_XML_and_HTML_character_entity_references
private let characterEntities : [ String : Character ] = [
    //XML predefined entities:
    """    : "\"",
    "&"     : "&",
    "'"    : "'",
    "&lt;"      : "<",
    "&gt;"      : ">",

    //HTML character entity references:
    "&nbsp;"    : "\u{00a0}",
    //...
    "&diams;"   : "♦",
]

extension String {

    ///Returns a new string made by replacing in the `String`
    ///all HTML character entity references with the corresponding
    ///character.
    var stringByDecodingHTMLEntities : String {

        //===== Utility functions =====

        //Convert the number in the string to the corresponding
        //Unicode character, e.g.
        //   decodeNumeric("64", 10)   --> "@"
        //   decodeNumeric("20ac", 16) --> "€"
        func decodeNumeric(string : String, base : Int32) -> Character? {
            let code = UInt32(strtoul(string, nil, base))
            return Character(UnicodeScalar(code))
        }

        //Decode the HTML character entity to the corresponding
        //Unicode character, return `nil` for invalid input.
        //    decode("&#64;")    --> "@"
        //    decode("&#x20ac;") --> "€"
        //    decode("&lt;")     --> "<"
        //    decode("&foo;")    --> nil
        func decode(entity : String) -> Character? {

            if entity.hasPrefix("&#x") || entity.hasPrefix("&#X"){
                return decodeNumeric(entity.substringFromIndex(entity.startIndex.advancedBy(3)), base: 16)
            } else if entity.hasPrefix("&#") {
                return decodeNumeric(entity.substringFromIndex(entity.startIndex.advancedBy(2)), base: 10)
            } else {
                return characterEntities[entity]
            }
        }

        //===== Method starts here =====

        var result = ""
        var position = startIndex

        //Find the next '&' and copy the characters preceding it to `result`:
        while let ampRange = self.rangeOfString("&", range: position ..< endIndex) {
            result.appendContentsOf(self[position ..< ampRange.startIndex])
            position = ampRange.startIndex

            //Find the next ';' and copy everything from '&' to ';' into `entity`
            if let semiRange = self.rangeOfString(";", range: position ..< endIndex) {
                let entity = self[position ..< semiRange.endIndex]
                position = semiRange.endIndex

                if let decoded = decode(entity) {
                    //Replace by decoded character:
                    result.append(decoded)
                } else {
                    //Invalid entity, copy verbatim:
                    result.appendContentsOf(entity)
                }
            } else {
                //No matching ';'.
                break
            }
        }
        //Copy remaining characters to `result`:
        result.appendContentsOf(self[position ..< endIndex])
        return result
    }
}

InformationsquelleAutor Martin R

Swift 2 version von @akashivskyy Verlängerung,

 extension String {
     init(htmlEncodedString: String) {
         if let encodedData = htmlEncodedString.dataUsingEncoding(NSUTF8StringEncoding){
             let attributedOptions : [String: AnyObject] = [
            NSDocumentTypeDocumentAttribute: NSHTMLTextDocumentType,
            NSCharacterEncodingDocumentAttribute: NSUTF8StringEncoding
        ]

             do{
                 if let attributedString:NSAttributedString = try NSAttributedString(data: encodedData, options: attributedOptions, documentAttributes: nil){
                     self.init(attributedString.string)
                 }else{
                     print("error")
                     self.init(htmlEncodedString)     //Returning actual string if there is an error
                 }
             }catch{
                 print("error: \(error)")
                 self.init(htmlEncodedString)     //Returning actual string if there is an error
             }

         }else{
             self.init(htmlEncodedString)     //Returning actual string if there is an error
         }
     }
 }

InformationsquelleAutor Zaid Pathan

extension String{
    func decodeEnt() -> String{
        let encodedData = self.dataUsingEncoding(NSUTF8StringEncoding)!
        let attributedOptions : [String: AnyObject] = [
            NSDocumentTypeDocumentAttribute: NSHTMLTextDocumentType,
            NSCharacterEncodingDocumentAttribute: NSUTF8StringEncoding
        ]
        let attributedString = NSAttributedString(data: encodedData, options: attributedOptions, documentAttributes: nil, error: nil)!

        return attributedString.string
    }
}

let encodedString = "The Weeknd ‘King Of The Fall’"

let foo = encodedString.decodeEnt() // The Weeknd ‘King Of The Fall’

InformationsquelleAutor wLc

Ich war auf der Suche nach einer reinen Swift-3.0-Dienstprogramm, um escape/unescape aus HTML-character-Referenzen (D. H. für server-side-Swift-apps auf macOS und Linux) aber nicht finden umfassende Lösungen, so schrieb ich meine eigene Implementierung: https://github.com/IBM-Swift/swift-html-entities

Paket HTMLEntities arbeitet mit HTML4 character benannt Verweise sowie hex/dec numeric character references, und es wird erkennen, spezielle numerische character references pro die W3 HTML5-Spezifikation (d.h. € werden sollte, ohne Umschreibung, wie das Euro-Zeichen (unicode -U+20AC) und NICHT, wie das unicode-Zeichen für U+0080, und bestimmte Bereiche von numeric character references ersetzt werden sollten, die mit den Ersatz-Zeichen U+FFFD wenn unescaping).

Beispiel:

import HTMLEntities

//encode example
let html = "<script>alert(\"abc\")</script>"

print(html.htmlEscape())
//Prints ”&lt;script&gt;alert(&quot;abc&quot;)&lt;/script&gt;"

//decode example
let htmlencoded = "&lt;script&gt;alert(&quot;abc&quot;)&lt;/script&gt;"

print(htmlencoded.htmlUnescape())
// Prints ”<script>alert(\"abc\")</script>"

Und für OP ' s Beispiel:

print("The Weeknd ‘King Of The Fall’ [Video Premiere] | @TheWeeknd | #SoPhi ".htmlUnescape())
// prints "The Weeknd ‘King Of The Fall’ [Video Premiere] | @TheWeeknd | #SoPhi "

Edit: HTMLEntities unterstützt jetzt HTML5 benannte Zeichenreferenzen, wie in der version 2.0.0. Spec-konform ist-Analyse wird auch umgesetzt.

InformationsquelleAutor Youming Lin

Wäre dies mein Ansatz. Fügen Sie die Entitäten Wörterbuch von https://gist.github.com/mwaterfall/25b4a6a06dc3309d9555 Michael Wasserfall erwähnt.

extension String {
    func htmlDecoded()->String {

        guard (self != "") else { return self }

        var newStr = self

        let entities = [
            """    : "\"",
            "&"     : "&",
            "'"    : "'",
            "&lt;"      : "<",
            "&gt;"      : ">",
        ]

        for (name,value) in entities {
            newStr = newStr.stringByReplacingOccurrencesOfString(name, withString: value)
        }
        return newStr
    }
}

Beispiele:

let encoded = "this is so "good""
let decoded = encoded.htmlDecoded() // "this is so "good""

ODER

let encoded = "this is so "good"".htmlDecoded() // "this is so "good""

InformationsquelleAutor Bseaborn

Aktualisiert, Antwort arbeiten auf Swift 3

    extension String {
        init?(htmlEncodedString: String) {
            let encodedData = htmlEncodedString.data(using: String.Encoding.utf8)!
            let attributedOptions = [ NSDocumentTypeDocumentAttribute: NSHTMLTextDocumentType]

            guard let attributedString = try? NSAttributedString(data: encodedData, options: attributedOptions, documentAttributes: nil) else {
                return nil
           }
            self.init(attributedString.string)
}

InformationsquelleAutor ravalboy

Swift 4:

Die gesamte Lösung, die schließlich für mich gearbeitet mit html-code und neue-Zeile-Zeichen und Anführungszeichen

extension String {
    var htmlDecoded: String {
        let decoded = try? NSAttributedString(data: Data(utf8), options: [
            .documentType: NSAttributedString.DocumentType.html,
            .characterEncoding: String.Encoding.utf8.rawValue
            ], documentAttributes: nil).string

        return decoded ?? self
    }
}

Verwendung:

let yourStringEncoded = yourStringWithHtmlcode.htmlDecoded

Hatte ich dann etwas mehr Filter um loszuwerden single quotes ( zB: don't, hasn't, It's etc), und neue-Zeile-Zeichen wie \n

var yourNewString = String(yourStringEncoded.filter { !"\n\t\r".contains($0) })
yourNewString = yourNewString.replacingOccurrences(of: "\'", with: "", options: NSString.CompareOptions.literal, range: nil)

InformationsquelleAutor Naishta

Swift-3.0-version mit der tatsächlichen Schriftgröße Umwandlung

In der Regel, wenn Sie direkt konvertieren von html in zugeschrieben Zeichenfolge, die Schriftgröße wird erhöht. Sie können versuchen, zu konvertieren von html-string zugeschrieben string und wieder zurück um den Unterschied zu sehen.

Statt, hier ist die tatsächliche Größe Konvertierung , stellen Sie sicher, dass die Schriftgröße nicht ändern, indem die 0,75-Verhältnis auf alle Schriften

extension String {
    func htmlAttributedString() -> NSAttributedString? {
        guard let data = self.data(using: String.Encoding.utf16, allowLossyConversion: false) else { return nil }
        guard let attriStr = try? NSMutableAttributedString(
            data: data,
            options: [NSDocumentTypeDocumentAttribute: NSHTMLTextDocumentType],
            documentAttributes: nil) else { return nil }
        attriStr.beginEditing()
        attriStr.enumerateAttribute(NSFontAttributeName, in: NSMakeRange(0, attriStr.length), options: .init(rawValue: 0)) {
            (value, range, stop) in
            if let font = value as? UIFont {
                let resizedFont = font.withSize(font.pointSize * 0.75)
                attriStr.addAttribute(NSFontAttributeName,
                                         value: resizedFont,
                                         range: range)
            }
        }
        attriStr.endEditing()
        return attriStr
    }
}

InformationsquelleAutor Fangming

Haben Sie einen Blick auf HTMLString - eine Bibliothek, geschrieben in Swift, die erlaubt, dass Sie Ihr Programm zum hinzufügen und entfernen von HTML-entities in Strings

Für die Vollständigkeit, die ich kopiert wichtigsten features von der Website:

• Fügt Entitäten für ASCII und UTF-8/UTF-16-Codierungen
• Entfernt mehr als 2100 named entities (wie &)
• Unterstützt das entfernen von dezimal-und hexadezimal-Entitäten
• Entwickelt zur Unterstützung von Swift-Extended Grapheme Cluster (→ 100% emoji-Nachweis)
• Komplett unit getestet
• Schnell
• Dokumentiert
• Kompatibel mit Objective-C

InformationsquelleAutor Despotovic

Swift4

Ich mag die Lösung mit documentAttributes aber es ist möglicherweise zu langsam für das Parsen von Dateien und/oder Nutzung in der Tabellenansicht Zellen. Ich kann;t glauben, dass Apple nicht bieten eine anständige Lösung für dieses.

Als eine Abhilfe, die ich gefunden habe auf GitHub dieser String-Erweiterung, die funktioniert perfekt und schnell für die Decodierung.

Also für Situationen, in denen die gegebene Antwort ist zu langsam sehen die Lösung vorschlagen, in diesem link:
https://gist.github.com/mwaterfall/25b4a6a06dc3309d9555
Anmerkung: es ist nicht Parsen von HTML-tags.

InformationsquelleAutor Vincent

NSData dataRes = (nsdata-Wert )

var resString = NSString(Daten: dataRes, Kodierung: NSUTF8StringEncoding)

InformationsquelleAutor Yogesh shelke