J'utilise une instance de UIWebViewpour traiter du texte et le colorier correctement, cela donne le résultat au format HTML mais plutôt que de l'afficher dans le UIWebViewJe veux l'afficher en utilisant Core Textavec un NSAttributedString.

Je suis capable de créer et de dessiner le NSAttributedStringmais je ne sais pas comment je peux convertir et mapper le HTML dans la chaîne attribuée.

Je comprends que sous Mac OS X NSAttributedStringa une initWithHTML:méthode, mais il s'agissait d'un ajout uniquement Mac et n'est pas disponible pour iOS.

Je sais aussi qu'il y a une question similaire à celle-ci, mais elle n'a pas de réponse, je pensais que j'essaierais à nouveau et voir si quelqu'un a créé un moyen de le faire et si oui, s'il pouvait le partager.

Dans iOS 7, UIKit a ajouté une initWithData:options:documentAttributes:error:méthode qui peut initialiser un en NSAttributedStringutilisant HTML, par exemple:

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

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

Il existe un ajout open source en cours de développement à NSAttributedString par Oliver Drobnik sur Github. Il utilise NSScanner pour l'analyse HTML.

La création d'un NSAttributedString à partir de HTML doit être effectuée sur le thread principal!

Mise à jour: Il s'avère que le rendu HTML de NSAttributedString dépend de WebKit sous le capot et doit être exécuté sur le thread principal, sinon il plantera parfois l'application avec un SIGTRAP .

Journal des plantages de New Relic:

Vous trouverez ci-dessous une extension Swift 2 String sécurisée pour les threads :

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

Usage:

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

Production:

Extension d'initialisation Swift sur NSAttributedString

Mon inclination était d'ajouter ceci comme une extension à NSAttributedStringplutôt que String. Je l'ai essayé en tant qu'extension statique et initialiseur. Je préfère l'initialiseur qui est ce que j'ai inclus ci-dessous.

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

Exemple

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

Il s'agit d'une Stringextension écrite en Swift pour renvoyer une chaîne HTML sous la forme 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
    }
}

Utiliser,

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

Dans ce qui précède, j'ai volontairement ajouté un unicode \ u2022 pour montrer qu'il restitue correctement unicode.

Un trivial: l'encodage par défaut qui NSAttributedStringutilise est NSUTF16StringEncoding(pas UTF8!).

Fait quelques modifications sur Andrew la solution d' et mise à jour du code vers Swift 3:

Ce code utilise maintenant UITextView comme selfet peut hériter de sa police d'origine, de sa taille de police et de sa couleur de texte

Remarque: toHexString()est l'extension d' ici

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

Exemple d'utilisation:

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

Version de Swift 3.0 Xcode 8

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

• Initialiseur de commodité NSAttributedString
• Sans gardes supplémentaires
• jette une erreur

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

}

Usage

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

La seule solution que vous avez actuellement est d'analyser le HTML, de créer des nœuds avec des attributs point / font / etc donnés, puis de les combiner dans un NSAttributedString. C'est beaucoup de travail, mais s'il est fait correctement, il peut être réutilisable à l'avenir.

La solution ci-dessus est correcte.

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

Mais l'application wioll plante si vous l'exécutez sur iOS 8.1, 2 ou 3.

Pour éviter le plantage, ce que vous pouvez faire est: exécutez ceci dans une file d'attente. Pour qu'il soit toujours sur le fil principal.

L'utilisation de NSHTMLTextDocumentType est lente et il est difficile de contrôler les styles. Je vous suggère d'essayer ma bibliothèque qui s'appelle Atributika. Il possède son propre analyseur HTML très rapide. Vous pouvez également avoir n'importe quel nom de balise et définir n'importe quel style pour eux.

Exemple:

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

label.attributedText = str

Vous pouvez le trouver ici https://github.com/psharanda/Atributika

Swift 3 :
Essayez ceci :

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

Et pour utiliser:

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

Extensions utiles

Inspiré par ce fil, un pod et l'exemple ObjC d'Erica Sadun dans iOS Gourmet Cookbook p.80, j'ai écrit une extension encore Stringet encore NSAttributedStringpour aller et venir entre les chaînes HTML simples et NSAttributedStrings et vice versa - sur GitHub ici , qui J'ai trouvé utile.

Les signatures sont (encore une fois, le code complet dans un Gist, lien ci-dessus):

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 }

avec police

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

Vous pouvez également utiliser les versions dont il a été dérivé et définir la police sur UILabel après avoir défini attribuéString

La conversion intégrée définit toujours la couleur du texte sur UIColor.black, même si vous passez un dictionnaire d'attributs avec .forgroundColor défini sur autre chose. Pour prendre en charge le mode DARK sur iOS 13, essayez cette version de l'extension sur 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)
    }
}