Sto usando un'istanza di UIWebViewper elaborare un po 'di testo e colorarlo correttamente, dà il risultato come HTML ma invece di visualizzarlo nel UIWebViewvoglio visualizzarlo usando Core Textcon a NSAttributedString.

Sono in grado di creare e disegnare il NSAttributedStringma non sono sicuro di come posso convertire e mappare l'HTML nella stringa attribuita.

Capisco che sotto Mac OS X NSAttributedStringha un initWithHTML:metodo ma questa era un'aggiunta solo per Mac e non è disponibile per iOS.

So anche che esiste una domanda simile a questa, ma non ha avuto risposte, anche se proverei di nuovo e vedrei se qualcuno ha creato un modo per farlo e, in tal caso, se potesse condividerlo.

In iOS 7, UIKit ha aggiunto un initWithData:options:documentAttributes:error:metodo che può inizializzare un NSAttributedStringutilizzo di HTML, ad esempio:

[[NSAttributedString alloc] initWithData:[htmlString dataUsingEncoding:NSUTF8StringEncoding] 
                                 options:@{NSDocumentTypeDocumentAttribute: NSHTMLTextDocumentType,
                                           NSCharacterEncodingDocumentAttribute: @(NSUTF8StringEncoding)} 
                      documentAttributes:nil error:nil];

In Swift:

let htmlData = NSString(string: details).data(using: String.Encoding.unicode.rawValue)
let options = [NSAttributedString.DocumentReadingOptionKey.documentType:
        NSAttributedString.DocumentType.html]
let attributedString = try? NSMutableAttributedString(data: htmlData ?? Data(),
                                                          options: options,
                                                          documentAttributes: nil)

C'è un'aggiunta open source work-in-progress a NSAttributedString di Oliver Drobnik a Github. Utilizza NSScanner per l'analisi HTML.

La creazione di un NSAttributedString da HTML deve essere eseguita sul thread principale!

Aggiornamento: Si scopre che il rendering HTML di NSAttributedString dipende da WebKit sotto il cofano e deve essere eseguito sul thread principale o occasionalmente si blocca l'app con un SIGTRAP .

Nuovo registro degli arresti reliquia:

Di seguito è riportata un'estensione della stringa Swift 2 thread-safe aggiornata :

extension String {
    func attributedStringFromHTML(completionBlock:NSAttributedString? ->()) {
        guard let data = dataUsingEncoding(NSUTF8StringEncoding) else {
            print("Unable to decode data from html string: \(self)")
            return completionBlock(nil)
        }

        let options = [NSDocumentTypeDocumentAttribute : NSHTMLTextDocumentType,
                   NSCharacterEncodingDocumentAttribute: NSNumber(unsignedInteger:NSUTF8StringEncoding)]

        dispatch_async(dispatch_get_main_queue()) {
            if let attributedString = try? NSAttributedString(data: data, options: options, documentAttributes: nil) {
                completionBlock(attributedString)
            } else {
                print("Unable to create attributed string from html string: \(self)")
                completionBlock(nil)
            }
        }
    }
}

Uso:

let html = "<center>Here is some <b>HTML</b></center>"
html.attributedStringFromHTML { attString in
    self.bodyLabel.attributedText = attString
}

Produzione:

Estensione di inizializzazione rapida su NSAttributedString

La mia inclinazione era quella di aggiungere questo come estensione NSAttributedStringpiuttosto che String. L'ho provato come estensione statica e inizializzatore. Preferisco l'inizializzatore che è quello che ho incluso di seguito.

Swift 4

internal convenience init?(html: String) {
    guard let data = html.data(using: String.Encoding.utf16, allowLossyConversion: false) else {
        return nil
    }

    guard let attributedString = try?  NSAttributedString(data: data, options: [.documentType: NSAttributedString.DocumentType.html, .characterEncoding: String.Encoding.utf8.rawValue], documentAttributes: nil) else {
        return nil
    }

    self.init(attributedString: attributedString)
}

Swift 3

extension NSAttributedString {

internal convenience init?(html: String) {
    guard let data = html.data(using: String.Encoding.utf16, allowLossyConversion: false) else {
        return nil
    }

    guard let attributedString = try? NSMutableAttributedString(data: data, options: [NSAttributedString.DocumentReadingOptionKey.documentType: NSAttributedString.DocumentType.html], documentAttributes: nil) else {
        return nil
    }

    self.init(attributedString: attributedString)
}
}

Esempio

let html = "<b>Hello World!</b>"
let attributedString = NSAttributedString(html: html)

Questa è Stringun'estensione scritta in Swift per restituire una stringa HTML come NSAttributedString.

extension String {
    func htmlAttributedString() -> NSAttributedString? {
        guard let data = self.dataUsingEncoding(NSUTF16StringEncoding, allowLossyConversion: false) else { return nil }
        guard let html = try? NSMutableAttributedString(data: data, options: [NSDocumentTypeDocumentAttribute: NSHTMLTextDocumentType], documentAttributes: nil) else { return nil }
        return html
    }
}

Usare,

label.attributedText = "<b>Hello</b> \u{2022} babe".htmlAttributedString()

In quanto sopra, ho volutamente aggiunto un unicode \ u2022 per mostrare che rende unicode correttamente.

Un banale: la codifica predefinita che NSAttributedStringutilizza è NSUTF16StringEncoding(non UTF8!).

Apportate alcune modifiche alla soluzione di Andrew e aggiorna il codice a Swift 3:

Questo codice ora utilizza UITextView come selfe in grado di ereditare il carattere originale, la dimensione del carattere e il colore del testo

Nota: toHexString()è l'estensione da qui

extension UITextView {
    func setAttributedStringFromHTML(_ htmlCode: String, completionBlock: @escaping (NSAttributedString?) ->()) {
        let inputText = "\(htmlCode)<style>body { font-family: '\((self.font?.fontName)!)'; font-size:\((self.font?.pointSize)!)px; color: \((self.textColor)!.toHexString()); }</style>"

        guard let data = inputText.data(using: String.Encoding.utf16) else {
            print("Unable to decode data from html string: \(self)")
            return completionBlock(nil)
        }

        DispatchQueue.main.async {
            if let attributedString = try? NSAttributedString(data: data, options: [NSDocumentTypeDocumentAttribute: NSHTMLTextDocumentType], documentAttributes: nil) {
                self.attributedText = attributedString
                completionBlock(attributedString)
            } else {
                print("Unable to create attributed string from html string: \(self)")
                completionBlock(nil)
            }
        }
    }
}

Esempio di utilizzo:

mainTextView.setAttributedStringFromHTML("<i>Hello world!</i>") { _ in }

Swift 3.0 Xcode 8 Version

func htmlAttributedString() -> NSAttributedString? {
    guard let data = self.data(using: String.Encoding.utf16, allowLossyConversion: false) else { return nil }
    guard let html = try? NSMutableAttributedString(data: data, options: [NSDocumentTypeDocumentAttribute: NSHTMLTextDocumentType], documentAttributes: nil) else { return nil }
    return html
}

Swift 4

• Inizializzatore convenienza NSAttributedString
• Senza protezioni extra
• genera errore

extension NSAttributedString {

    convenience init(htmlString html: String) throws {
        try self.init(data: Data(html.utf8), options: [
            .documentType: NSAttributedString.DocumentType.html,
            .characterEncoding: String.Encoding.utf8.rawValue
        ], documentAttributes: nil)
    }

}

uso

UILabel.attributedText = try? NSAttributedString(htmlString: "<strong>Hello</strong> World!")

L'unica soluzione che hai in questo momento è analizzare l'HTML, creare alcuni nodi con determinati attributi point / font / etc, quindi combinarli insieme in un NSAttributedString. È un sacco di lavoro, ma se fatto correttamente, può essere riutilizzabile in futuro.

La soluzione sopra è corretta.

[[NSAttributedString alloc] initWithData:[htmlString dataUsingEncoding:NSUTF8StringEncoding] 
                                 options:@{NSDocumentTypeDocumentAttribute: NSHTMLTextDocumentType,
                                           NSCharacterEncodingDocumentAttribute: @(NSUTF8StringEncoding)} 
                      documentAttributes:nil error:nil];

Ma l'app si bloccherà se la stai eseguendo su iOS 8.1,2 o 3.

Per evitare il crash ciò che puoi fare è: eseguilo in una coda. In modo che sia sempre sul thread principale.

L'uso di NSHTMLTextDocumentType è lento ed è difficile controllare gli stili. Ti suggerisco di provare la mia biblioteca che si chiama Atributika. Ha un proprio parser HTML molto veloce. Inoltre puoi avere qualsiasi nome di tag e definire qualsiasi stile per loro.

Esempio:

let str = "<strong>Hello</strong> World!".style(tags:
    Style("strong").font(.boldSystemFont(ofSize: 15))).attributedString

label.attributedText = str

Puoi trovarlo qui https://github.com/psharanda/Atributika

Swift 3 :
prova questo :

extension String {
    func htmlAttributedString() -> NSAttributedString? {
        guard let data = self.data(using: String.Encoding.utf16, allowLossyConversion: false) else { return nil }
        guard let html = try? NSMutableAttributedString(
            data: data,
            options: [NSDocumentTypeDocumentAttribute: NSHTMLTextDocumentType],
            documentAttributes: nil) else { return nil }
        return html
    }
}  

E per l'utilizzo:

let str = "<h1>Hello bro</h1><h2>Come On</h2><h3>Go sis</h3><ul><li>ME 1</li><li>ME 2</li></ul> <p>It is me bro , remember please</p>"

self.contentLabel.attributedText = str.htmlAttributedString()

Estensioni utili

Ispirato da questo thread, un pod e dall'esempio ObjC di Erica Sadun in iOS Gourmet Cookbook p.80, ho scritto un'estensione avanti Stringe NSAttributedStringindietro per andare avanti e indietro tra le stringhe HTML e NSAttributedStrings e viceversa - su GitHub qui , che Ho trovato utile.

Le firme sono (di nuovo, codice completo in un Gist, link sopra):

extension NSAttributedString {
    func encodedString(ext: DocEXT) -> String?
    static func fromEncodedString(_ eString: String, ext: DocEXT) -> NSAttributedString? 
    static func fromHTML(_ html: String) -> NSAttributedString? // same as above, where ext = .html
}

extension String {
    func attributedString(ext: DocEXT) -> NSAttributedString?
}

enum DocEXT: String { case rtfd, rtf, htm, html, txt }

con carattere

extension NSAttributedString
{
internal convenience init?(html: String, font: UIFont? = nil) {
    guard let data = html.data(using: String.Encoding.utf16, allowLossyConversion: false) else {
        return nil
    }
    assert(Thread.isMainThread)
    guard let attributedString = try?  NSAttributedString(data: data, options: [.documentType: NSAttributedString.DocumentType.html, .characterEncoding: String.Encoding.utf8.rawValue], documentAttributes: nil) else {
        return nil
    }
    let mutable = NSMutableAttributedString(attributedString: attributedString)
    if let font = font {
        mutable.addAttribute(.font, value: font, range: NSRange(location: 0, length: mutable.length))
    }
    self.init(attributedString: mutable)
}
}

in alternativa puoi usare le versioni da cui è stato derivato e impostare font su UILabel dopo aver impostato gli attributiString

La conversione integrata imposta sempre il colore del testo su UIColor.black, anche se si passa un dizionario di attributi con .forgroundColor impostato su qualcos'altro. Per supportare la modalità SCURO su iOS 13, prova questa versione dell'estensione su NSAttributedString.

extension NSAttributedString {
    internal convenience init?(html: String)                    {
        guard 
            let data = html.data(using: String.Encoding.utf16, allowLossyConversion: false) else { return nil }

        let options : [DocumentReadingOptionKey : Any] = [
            .documentType: NSAttributedString.DocumentType.html,
            .characterEncoding: String.Encoding.utf8.rawValue
        ]

        guard
            let string = try? NSMutableAttributedString(data: data, options: options,
                                                 documentAttributes: nil) else { return nil }

        if #available(iOS 13, *) {
            let colour = [NSAttributedString.Key.foregroundColor: UIColor.label]
            string.addAttributes(colour, range: NSRange(location: 0, length: string.length))
        }

        self.init(attributedString: string)
    }
}