Supprimer des balises HTML d'une chaîne

Existe-t-il un bon moyen de supprimer le HTML d'une chaîne Java? Un regex simple comme

 replaceAll("\\<.*?>","") 

fonctionnera, mais des choses comme &ne seront pas converties correctement et le non-HTML entre les deux crochets sera supprimé (c'est- .*?à- dire que dans l'expression régulière disparaîtra).

Utilisez un analyseur HTML au lieu de regex. C'est très simple avec Jsoup .

public static String html2text(String html) {
    return Jsoup.parse(html).text();
}

Jsoup prend également en charge la suppression des balises HTML par rapport à une liste blanche personnalisable, ce qui est très utile si vous souhaitez autoriser uniquement, par exemple <b>, <i>et <u>.

Voir également:

• Les balises ouvertes RegEx correspondent aux balises autonomes XHTML
• Quels sont les avantages et les inconvénients des principaux analyseurs HTML Java?
• Prévention XSS dans l'application Web JSP / Servlet

Si vous écrivez pour Android, vous pouvez le faire ...

android.text.Html.fromHtml(instruction).toString()

Si l'utilisateur entre <b>hey!</b>, voulez-vous afficher <b>hey!</b>ou hey!? Si c'est le premier, échappez à less-thans et html-encode esperluette (et éventuellement des guillemets) et tout va bien. Une modification de votre code pour implémenter la deuxième option serait:

replaceAll("\\<[^>]*>","")

mais vous rencontrerez des problèmes si l'utilisateur entre quelque chose de malformé, comme <bhey!</b>.

Vous pouvez également consulter JTidy qui analysera les entrées html «sales» et devrait vous donner un moyen de supprimer les balises tout en conservant le texte.

Le problème avec la suppression du code HTML est que les navigateurs ont des analyseurs très cléments, plus clément que n'importe quelle bibliothèque que vous pouvez trouver, donc même si vous faites de votre mieux pour supprimer toutes les balises (en utilisant la méthode replace ci-dessus, une bibliothèque DOM ou JTidy) , vous devrez toujours vous assurer d'encoder tous les caractères spéciaux HTML restants pour garantir la sécurité de votre sortie.

Une autre façon consiste à utiliser javax.swing.text.html.HTMLEditorKit pour extraire le texte.

import java.io.*;
import javax.swing.text.html.*;
import javax.swing.text.html.parser.*;

public class Html2Text extends HTMLEditorKit.ParserCallback {
    StringBuffer s;

    public Html2Text() {
    }

    public void parse(Reader in) throws IOException {
        s = new StringBuffer();
        ParserDelegator delegator = new ParserDelegator();
        // the third parameter is TRUE to ignore charset directive
        delegator.parse(in, this, Boolean.TRUE);
    }

    public void handleText(char[] text, int pos) {
        s.append(text);
    }

    public String getText() {
        return s.toString();
    }

    public static void main(String[] args) {
        try {
            // the HTML to convert
            FileReader in = new FileReader("java-new.html");
            Html2Text parser = new Html2Text();
            parser.parse(in);
            in.close();
            System.out.println(parser.getText());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

ref: Supprimer les balises HTML d'un fichier pour extraire uniquement le TEXTE

Je pense que la façon la plus simple de filtrer les balises html est:

private static final Pattern REMOVE_TAGS = Pattern.compile("<.+?>");

public static String removeTags(String string) {
    if (string == null || string.length() == 0) {
        return string;
    }

    Matcher m = REMOVE_TAGS.matcher(string);
    return m.replaceAll("");
}

Aussi très simple avec Jericho , et vous pouvez conserver une partie de la mise en forme (sauts de ligne et liens, par exemple).

    Source htmlSource = new Source(htmlText);
    Segment htmlSeg = new Segment(htmlSource, 0, htmlSource.length());
    Renderer htmlRend = new Renderer(htmlSeg);
    System.out.println(htmlRend.toString());

La réponse acceptée de faire a simplement Jsoup.parse(html).text()2 problèmes potentiels (avec JSoup 1.7.3):

• Il supprime les sauts de ligne du texte
• Il convertit le texte <script>en<script>

Si vous l'utilisez pour vous protéger contre XSS, c'est un peu ennuyeux. Voici ma meilleure image d'une solution améliorée, utilisant à la fois JSoup et Apache StringEscapeUtils:

// breaks multi-level of escaping, preventing &amp;lt;script&amp;gt; to be rendered as <script>
String replace = input.replace("&amp;", "");
// decode any encoded html, preventing &lt;script&gt; to be rendered as <script>
String html = StringEscapeUtils.unescapeHtml(replace);
// remove all html tags, but maintain line breaks
String clean = Jsoup.clean(html, "", Whitelist.none(), new Document.OutputSettings().prettyPrint(false));
// decode html again to convert character entities back into text
return StringEscapeUtils.unescapeHtml(clean);

Notez que la dernière étape est parce que je dois utiliser la sortie en texte brut. Si vous n'avez besoin que d'une sortie HTML, vous devriez pouvoir la supprimer.

Et voici un tas de cas de test (entrée à sortie):

{"regular string", "regular string"},
{"<a href=\"link\">A link</a>", "A link"},
{"<script src=\"http://evil.url.com\"/>", ""},
{"&lt;script&gt;", ""},
{"&amp;lt;script&amp;gt;", "lt;scriptgt;"}, // best effort
{"\" ' > < \n \\ é å à ü and & preserved", "\" ' > < \n \\ é å à ü and & preserved"}

Si vous trouvez un moyen de l'améliorer, faites-le moi savoir.

Sur Android, essayez ceci:

String result = Html.fromHtml(html).toString();

L'échappement HTML est vraiment difficile à faire correctement - je suggérerais certainement d'utiliser le code de bibliothèque pour ce faire, car c'est beaucoup plus subtil que vous ne le pensez. Consultez StringEscapeUtils d' Apache pour une assez bonne bibliothèque pour gérer cela en Java.

Cela devrait fonctionner -

utilisez ceci

  text.replaceAll('<.*?>' , " ") -> This will replace all the html tags with a space.

et ça

  text.replaceAll('&.*?;' , "")-> this will replace all the tags which starts with "&" and ends with ";" like  , &, > etc.

Vous voudrez peut-être remplacer <br/>et</p> des étiquettes avec des sauts de ligne avant de se dénuder le code HTML pour l' empêcher de devenir un gâchis illisible comme le suggère Tim.

La seule façon dont je peux penser à supprimer des balises HTML, mais de laisser du non-HTML entre les crochets angulaires serait de comparer avec une liste de balises HTML . Quelque chose dans ce sens ...

replaceAll("\\<[\s]*tag[^>]*>","")

Décodez ensuite des caractères spéciaux tels que HTML &. Le résultat ne doit pas être considéré comme désinfecté.

Alternativement, on peut utiliser HtmlCleaner :

private CharSequence removeHtmlFrom(String html) {
    return new HtmlCleaner().clean(html).getText();
}

La réponse acceptée n'a pas fonctionné pour moi pour le cas de test que j'ai indiqué: le résultat de "a <b ou b> c" est "ab ou b> c".

J'ai donc utilisé TagSoup à la place. Voici une photo qui a fonctionné pour mon cas de test (et quelques autres):

import java.io.IOException;
import java.io.StringReader;
import java.util.logging.Logger;

import org.ccil.cowan.tagsoup.Parser;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.InputSource;
import org.xml.sax.Locator;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;

/**
 * Take HTML and give back the text part while dropping the HTML tags.
 *
 * There is some risk that using TagSoup means we'll permute non-HTML text.
 * However, it seems to work the best so far in test cases.
 *
 * @author dan
 * @see <a href="http://home.ccil.org/~cowan/XML/tagsoup/">TagSoup</a> 
 */
public class Html2Text2 implements ContentHandler {
private StringBuffer sb;

public Html2Text2() {
}

public void parse(String str) throws IOException, SAXException {
    XMLReader reader = new Parser();
    reader.setContentHandler(this);
    sb = new StringBuffer();
    reader.parse(new InputSource(new StringReader(str)));
}

public String getText() {
    return sb.toString();
}

@Override
public void characters(char[] ch, int start, int length)
    throws SAXException {
    for (int idx = 0; idx < length; idx++) {
    sb.append(ch[idx+start]);
    }
}

@Override
public void ignorableWhitespace(char[] ch, int start, int length)
    throws SAXException {
    sb.append(ch);
}

// The methods below do not contribute to the text
@Override
public void endDocument() throws SAXException {
}

@Override
public void endElement(String uri, String localName, String qName)
    throws SAXException {
}

@Override
public void endPrefixMapping(String prefix) throws SAXException {
}


@Override
public void processingInstruction(String target, String data)
    throws SAXException {
}

@Override
public void setDocumentLocator(Locator locator) {
}

@Override
public void skippedEntity(String name) throws SAXException {
}

@Override
public void startDocument() throws SAXException {
}

@Override
public void startElement(String uri, String localName, String qName,
    Attributes atts) throws SAXException {
}

@Override
public void startPrefixMapping(String prefix, String uri)
    throws SAXException {
}
}

Je sais que c'est vieux, mais je travaillais juste sur un projet qui m'obligeait à filtrer le HTML et cela a bien fonctionné:

noHTMLString.replaceAll("\\&.*?\\;", "");

au lieu de cela:

html = html.replaceAll(" ","");
html = html.replaceAll("&"."");

Voici une mise à jour légèrement plus étoffée pour essayer de gérer la mise en forme des pauses et des listes. J'ai utilisé la sortie d'Amaya comme guide.

import java.io.IOException;
import java.io.Reader;
import java.io.StringReader;
import java.util.Stack;
import java.util.logging.Logger;

import javax.swing.text.MutableAttributeSet;
import javax.swing.text.html.HTML;
import javax.swing.text.html.HTMLEditorKit;
import javax.swing.text.html.parser.ParserDelegator;

public class HTML2Text extends HTMLEditorKit.ParserCallback {
    private static final Logger log = Logger
            .getLogger(Logger.GLOBAL_LOGGER_NAME);

    private StringBuffer stringBuffer;

    private Stack<IndexType> indentStack;

    public static class IndexType {
        public String type;
        public int counter; // used for ordered lists

        public IndexType(String type) {
            this.type = type;
            counter = 0;
        }
    }

    public HTML2Text() {
        stringBuffer = new StringBuffer();
        indentStack = new Stack<IndexType>();
    }

    public static String convert(String html) {
        HTML2Text parser = new HTML2Text();
        Reader in = new StringReader(html);
        try {
            // the HTML to convert
            parser.parse(in);
        } catch (Exception e) {
            log.severe(e.getMessage());
        } finally {
            try {
                in.close();
            } catch (IOException ioe) {
                // this should never happen
            }
        }
        return parser.getText();
    }

    public void parse(Reader in) throws IOException {
        ParserDelegator delegator = new ParserDelegator();
        // the third parameter is TRUE to ignore charset directive
        delegator.parse(in, this, Boolean.TRUE);
    }

    public void handleStartTag(HTML.Tag t, MutableAttributeSet a, int pos) {
        log.info("StartTag:" + t.toString());
        if (t.toString().equals("p")) {
            if (stringBuffer.length() > 0
                    && !stringBuffer.substring(stringBuffer.length() - 1)
                            .equals("\n")) {
                newLine();
            }
            newLine();
        } else if (t.toString().equals("ol")) {
            indentStack.push(new IndexType("ol"));
            newLine();
        } else if (t.toString().equals("ul")) {
            indentStack.push(new IndexType("ul"));
            newLine();
        } else if (t.toString().equals("li")) {
            IndexType parent = indentStack.peek();
            if (parent.type.equals("ol")) {
                String numberString = "" + (++parent.counter) + ".";
                stringBuffer.append(numberString);
                for (int i = 0; i < (4 - numberString.length()); i++) {
                    stringBuffer.append(" ");
                }
            } else {
                stringBuffer.append("*   ");
            }
            indentStack.push(new IndexType("li"));
        } else if (t.toString().equals("dl")) {
            newLine();
        } else if (t.toString().equals("dt")) {
            newLine();
        } else if (t.toString().equals("dd")) {
            indentStack.push(new IndexType("dd"));
            newLine();
        }
    }

    private void newLine() {
        stringBuffer.append("\n");
        for (int i = 0; i < indentStack.size(); i++) {
            stringBuffer.append("    ");
        }
    }

    public void handleEndTag(HTML.Tag t, int pos) {
        log.info("EndTag:" + t.toString());
        if (t.toString().equals("p")) {
            newLine();
        } else if (t.toString().equals("ol")) {
            indentStack.pop();
            ;
            newLine();
        } else if (t.toString().equals("ul")) {
            indentStack.pop();
            ;
            newLine();
        } else if (t.toString().equals("li")) {
            indentStack.pop();
            ;
            newLine();
        } else if (t.toString().equals("dd")) {
            indentStack.pop();
            ;
        }
    }

    public void handleSimpleTag(HTML.Tag t, MutableAttributeSet a, int pos) {
        log.info("SimpleTag:" + t.toString());
        if (t.toString().equals("br")) {
            newLine();
        }
    }

    public void handleText(char[] text, int pos) {
        log.info("Text:" + new String(text));
        stringBuffer.append(text);
    }

    public String getText() {
        return stringBuffer.toString();
    }

    public static void main(String args[]) {
        String html = "<html><body><p>paragraph at start</p>hello<br />What is happening?<p>this is a<br />mutiline paragraph</p><ol>  <li>This</li>  <li>is</li>  <li>an</li>  <li>ordered</li>  <li>list    <p>with</p>    <ul>      <li>another</li>      <li>list        <dl>          <dt>This</dt>          <dt>is</dt>            <dd>sdasd</dd>            <dd>sdasda</dd>            <dd>asda              <p>aasdas</p>            </dd>            <dd>sdada</dd>          <dt>fsdfsdfsd</dt>        </dl>        <dl>          <dt>vbcvcvbcvb</dt>          <dt>cvbcvbc</dt>            <dd>vbcbcvbcvb</dd>          <dt>cvbcv</dt>          <dt></dt>        </dl>        <dl>          <dt></dt>        </dl></li>      <li>cool</li>    </ul>    <p>stuff</p>  </li>  <li>cool</li></ol><p></p></body></html>";
        System.out.println(convert(html));
    }
}

Utilisation Html.fromHtml

Les balises HTML sont

<a href=”…”> <b>,  <big>, <blockquote>, <br>, <cite>, <dfn>
<div align=”…”>,  <em>, <font size=”…” color=”…” face=”…”>
<h1>,  <h2>, <h3>, <h4>,  <h5>, <h6>
<i>, <p>, <small>
<strike>,  <strong>, <sub>, <sup>, <tt>, <u>

Selon les documentations officielles d'Android, toutes les balises dans le HTML s'afficheront comme une chaîne de remplacement générique que votre programme peut ensuite parcourir et remplacer par de vraies chaînes .

Html.formHtmlprend un Html.TagHandleret un Html.ImageGetter comme arguments ainsi que le texte à analyser.

Exemple

String Str_Html=" <p>This is about me text that the user can put into their profile</p> ";

alors

Your_TextView_Obj.setText(Html.fromHtml(Str_Html).toString());

Production

Il s'agit du texte que l'utilisateur peut mettre dans son profil

Voici une autre variante de la façon de tout remplacer (balises HTML | Entités HTML | Espace vide dans le contenu HTML)

content.replaceAll("(<.*?>)|(&.*?;)|([ ]{2,})", ""); où le contenu est une chaîne.

Vous pouvez simplement utiliser le filtre HTML par défaut d'Android

    public String htmlToStringFilter(String textToFilter){

    return Html.fromHtml(textToFilter).toString();

    }

La méthode ci-dessus renverra la chaîne filtrée HTML pour votre entrée.

Une autre façon peut être d'utiliser la classe com.google.gdata.util.common.html.HtmlToText comme

MyWriter.toConsole(HtmlToText.htmlToPlainText(htmlResponse));

Ce n'est cependant pas un code à l'épreuve des balles et lorsque je l'exécute sur des entrées wikipedia, j'obtiens également des informations de style. Cependant, je crois que pour les petits travaux / simples, ce serait efficace.

Il semble que vous souhaitiez passer du HTML au texte brut.
Si tel est le cas, consultez www.htmlparser.org. Voici un exemple qui supprime toutes les balises du fichier html trouvé sur une URL.
Il utilise org.htmlparser.beans.StringBean .

static public String getUrlContentsAsText(String url) {
    String content = "";
    StringBean stringBean = new StringBean();
    stringBean.setURL(url);
    content = stringBean.getStrings();
    return content;
}

Voici une autre façon de procéder:

public static String removeHTML(String input) {
    int i = 0;
    String[] str = input.split("");

    String s = "";
    boolean inTag = false;

    for (i = input.indexOf("<"); i < input.indexOf(">"); i++) {
        inTag = true;
    }
    if (!inTag) {
        for (i = 0; i < str.length; i++) {
            s = s + str[i];
        }
    }
    return s;
}

On pourrait également utiliser Apache Tika à cet effet. Par défaut, il préserve les espaces blancs du HTML supprimé, ce qui peut être souhaité dans certaines situations:

InputStream htmlInputStream = ..
HtmlParser htmlParser = new HtmlParser();
HtmlContentHandler htmlContentHandler = new HtmlContentHandler();
htmlParser.parse(htmlInputStream, htmlContentHandler, new Metadata())
System.out.println(htmlContentHandler.getBodyText().trim())

Une façon de conserver les informations de nouvelle ligne avec JSoup est de précéder toutes les nouvelles balises de ligne avec une chaîne factice, d'exécuter JSoup et de remplacer la chaîne factice par "\ n".

String html = "<p>Line one</p><p>Line two</p>Line three<br/>etc.";
String NEW_LINE_MARK = "NEWLINESTART1234567890NEWLINEEND";
for (String tag: new String[]{"</p>","<br/>","</h1>","</h2>","</h3>","</h4>","</h5>","</h6>","</li>"}) {
    html = html.replace(tag, NEW_LINE_MARK+tag);
}

String text = Jsoup.parse(html).text();

text = text.replace(NEW_LINE_MARK + " ", "\n\n");
text = text.replace(NEW_LINE_MARK, "\n\n");

classeString.replaceAll("\\<(/?[^\\>]+)\\>", "\\ ").replaceAll("\\s+", " ").trim() 

Mes 5 cents:

String[] temp = yourString.split("&");
String tmp = "";
if (temp.length > 1) {

    for (int i = 0; i < temp.length; i++) {
        tmp += temp[i] + "&";
    }
    yourString = tmp.substring(0, tmp.length() - 1);
}

Pour obtenir du texte html brut formaté, vous pouvez le faire:

String BR_ESCAPED = "<br/>";
Element el=Jsoup.parse(html).select("body");
el.select("br").append(BR_ESCAPED);
el.select("p").append(BR_ESCAPED+BR_ESCAPED);
el.select("h1").append(BR_ESCAPED+BR_ESCAPED);
el.select("h2").append(BR_ESCAPED+BR_ESCAPED);
el.select("h3").append(BR_ESCAPED+BR_ESCAPED);
el.select("h4").append(BR_ESCAPED+BR_ESCAPED);
el.select("h5").append(BR_ESCAPED+BR_ESCAPED);
String nodeValue=el.text();
nodeValue=nodeValue.replaceAll(BR_ESCAPED, "<br/>");
nodeValue=nodeValue.replaceAll("(\\s*<br[^>]*>){3,}", "<br/><br/>");

Pour obtenir du texte formaté, modifiez <br/> par \ n et modifiez la dernière ligne par:

nodeValue=nodeValue.replaceAll("(\\s*\n){3,}", "<br/><br/>");

Je sais que cela fait un moment que cette question n'a pas été posée, mais j'ai trouvé une autre solution, c'est ce qui a fonctionné pour moi:

Pattern REMOVE_TAGS = Pattern.compile("<.+?>");
    Source source= new Source(htmlAsString);
 Matcher m = REMOVE_TAGS.matcher(sourceStep.getTextExtractor().toString());
                        String clearedHtml= m.replaceAll("");

vous pouvez simplement créer une méthode avec multiple replaceAll () comme

String RemoveTag(String html){
   html = html.replaceAll("\\<.*?>","")
   html = html.replaceAll("&nbsp;","");
   html = html.replaceAll("&amp;"."");
   ----------
   ----------
   return html;
}

Utilisez ce lien pour les remplacements les plus courants dont vous avez besoin: http://tunes.org/wiki/html_20special_20characters_20and_20symbols.html

C'est simple mais efficace. J'utilise d'abord cette méthode pour supprimer les fichiers indésirables, mais pas la toute première ligne, c'est-à-dire replaceAll ("\ <. *?>", ""), Puis j'utilise des mots clés spécifiques pour rechercher des index, puis j'utilise .substring (start, end ) méthode pour éliminer les éléments inutiles. Comme c'est plus robuste et vous pouvez identifier exactement ce dont vous avez besoin dans toute la page html.

Supprimez les balises HTML de la chaîne. Quelque part, nous devons analyser une chaîne qui est reçue par certaines réponses comme Httpresponse du serveur.

Nous devons donc l'analyser.

Ici, je vais montrer comment supprimer les balises html de la chaîne.

    // sample text with tags

    string str = "<html><head>sdfkashf sdf</head><body>sdfasdf</body></html>";



    // regex which match tags

    System.Text.RegularExpressions.Regex rx = new System.Text.RegularExpressions.Regex("<[^>]*>");



    // replace all matches with empty strin

    str = rx.Replace(str, "");



    //now str contains string without html tags