使用jsoup将html转换为纯文本时如何保留行间距？

Question

使用jsoup将html转换为纯文本时如何保留行间距？

114

我有以下代码:

 public class NewClass {
     public String noTags(String str){
         return Jsoup.parse(str).text();
     }


     public static void main(String args[]) {
         String strings="<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN \">" +
         "<HTML> <HEAD> <TITLE></TITLE> <style>body{ font-size: 12px;font-family: verdana, arial, helvetica, sans-serif;}</style> </HEAD> <BODY><p><b>hello world</b></p><p><br><b>yo</b> <a href=\"http://google.com\">googlez</a></p></BODY> </HTML> ";

         NewClass text = new NewClass();
         System.out.println((text.noTags(strings)));
}

这是我的结果：

hello world yo googlez

但我想要换行：

hello world
yo googlez

我查看了jsoup的TextNode#getWholeText()，但我无法弄清如何使用它。

如果在我解析的标记中有<br>，如何在我的输出中获得换行？

- Billy

请编辑您的文本——您的问题中没有显示出换行符。通常在发布问题之前，请预览您的问题，以检查是否一切正常显示。 - Robin Green

我问了同样的问题（没有jsoup要求），但我仍然没有一个好的解决方案：https://dev59.com/-EzSa4cB1Zd3GeqPpcj8 - Eduardo

see @zeenosaur 's answer. - Jang-Ho Bae

15个回答

46

使用

Jsoup.parse("A\nB").text();

您已经产生了输出

"A B"

而不是

A

B

我使用以下方法:

descrizione = Jsoup.parse(html.replaceAll("(?i)<br[^>]*>", "br2n")).text();
text = descrizione.replaceAll("br2n", "\n");

- Mirco Attocchi

2

事实上，这只是一种简单的缓解措施，但在我看来，这应该由Jsoup库本身完全处理（它目前有一些令人不安的行为，比如这个 - 另外它是一个很棒的库！）。 - SRG

7

JSoup不是提供了DOM吗？为什么不直接用包含换行符的文本节点替换所有<br>元素，然后调用.text()方法，而要使用正则表达式进行转换呢？这样会导致某些字符串（比如<div title=<br>'not an attribute'></div>）输出不正确。 - Mike Samuel

5

好的，但是“descrizione”这个词从哪里来的呢？ - Steve Waters

"descrizione" 代表了纯文本所分配的变量。 - enigma969

45

Jsoup.clean(unsafeString, "", Whitelist.none(), new OutputSettings().prettyPrint(false));

我们正在这里使用这种方法：

public static String clean(String bodyHtml,
                       String baseUri,
                       Whitelist whitelist,
                       Document.OutputSettings outputSettings)

通过传递 Whitelist.none()，我们确保删除所有HTML。

通过传递 new OutputSettings().prettyPrint(false)，我们确保输出不被重新格式化并保留换行符。

- Paulius Z

这应该是唯一正确的答案。其他所有答案都假设只有 br 标签会产生新行。那么 HTML 中的任何其他块元素，如 div、p、ul 等呢？它们也都会引入新行。 - adarshr

10

使用此解决方案，HTML标记"<html><body><div>line 1</div><div>line 2</div><div>line 3</div></body></html>"生成的输出结果是："line 1line 2line 3"，没有换行符。 - JohnC

3

这对我不起作用；"<br>"没有创建换行。 - Grumblesaurus

谢谢！另外，“Whitelist”已被替换为“Safelist”类。 - kolobok

35

在 Jsoup v1.11.2 中，现在我们可以使用 Element.wholeText() 方法。

String cleanString = Jsoup.parse(htmlString).wholeText();

user121196的回答仍然有效。但是wholeText()会保留文本的对齐方式。

- zeenosaur

今天，2023年正在工作中 :-) 谢谢 - DoctorWho

24

使用jsoup试一试：

public static String cleanPreserveLineBreaks(String bodyHtml) {

    // get pretty printed html with preserved br and p tags
    String prettyPrintedBodyFragment = Jsoup.clean(bodyHtml, "", Whitelist.none().addTags("br", "p"), new OutputSettings().prettyPrint(true));
    // get plain text with preserved line breaks by disabled prettyPrint
    return Jsoup.clean(prettyPrintedBodyFragment, "", Whitelist.none(), new OutputSettings().prettyPrint(false));
}

- mkowa

很好，它可以工作，只需要进行一个小改变 new Document.OutputSettings().prettyPrint(true)。 - Ashu

这个解决方案将" "保留为文本，而不是将它们解析为空格。 - Andrei Volgin

11

对于更复杂的HTML，以上解决方案都不太合适；我成功地进行了转换并保留了换行符：

Document document = Jsoup.parse(myHtml);
String text = new HtmlToPlainText().getPlainText(document);

（版本1.10.3）

- Andy Res

是的，这做得很好。 - Mustafa

7

您可以遍历给定的元素。

public String convertNodeToText(Element element)
{
    final StringBuilder buffer = new StringBuilder();

    new NodeTraversor(new NodeVisitor() {
        boolean isNewline = true;

        @Override
        public void head(Node node, int depth) {
            if (node instanceof TextNode) {
                TextNode textNode = (TextNode) node;
                String text = textNode.text().replace('\u00A0', ' ').trim();                    
                if(!text.isEmpty())
                {                        
                    buffer.append(text);
                    isNewline = false;
                }
            } else if (node instanceof Element) {
                Element element = (Element) node;
                if (!isNewline)
                {
                    if((element.isBlock() || element.tagName().equals("br")))
                    {
                        buffer.append("\n");
                        isNewline = true;
                    }
                }
            }                
        }

        @Override
        public void tail(Node node, int depth) {                
        }                        
    }).traverse(element);        

    return buffer.toString();               
}

对于你的代码

String result = convertNodeToText(JSoup.parse(html))

- popcorny

我认为你应该在tail(node, depth)中测试isBlock，并且在离开块时添加\n，而不是进入块时添加。我正在这样做（即使用tail），这很好用。但是，如果像你一样使用head，那么这个：<p>line one<p>line two最终会变成一行。 - KajMagnus

new NodeTraversor(nodeVisitor).traverse(element);在新版本的Jsoup（目前为1.14.3）中已经不再适用。现在，NodeTraversor中的所有traverse方法都是static，因此应该像这样调用：NodeTraversor.traverse(nodeVisitor, element);。 - Pshemo

5

根据其他答案和这个问题的评论，大多数来这里的人似乎真正寻求的是一个通用解决方案，可以提供HTML文档的格式良好的纯文本表示。我知道我也是。

幸运的是，JSoup已经提供了一个非常全面的示例，说明如何实现这一点：HtmlToPlainText.java

示例中的FormattingVisitor可以轻松地按照您的喜好进行调整，并处理大多数块元素和换行。

为避免链接失效，这里是Jonathan Hedley的完整解决方案：

package org.jsoup.examples;

import org.jsoup.Jsoup;
import org.jsoup.helper.StringUtil;
import org.jsoup.helper.Validate;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.nodes.Node;
import org.jsoup.nodes.TextNode;
import org.jsoup.select.Elements;
import org.jsoup.select.NodeTraversor;
import org.jsoup.select.NodeVisitor;

import java.io.IOException;

/**
 * HTML to plain-text. This example program demonstrates the use of jsoup to convert HTML input to lightly-formatted
 * plain-text. That is divergent from the general goal of jsoup's .text() methods, which is to get clean data from a
 * scrape.
 * <p>
 * Note that this is a fairly simplistic formatter -- for real world use you'll want to embrace and extend.
 * </p>
 * <p>
 * To invoke from the command line, assuming you've downloaded the jsoup jar to your current directory:</p>
 * <p><code>java -cp jsoup.jar org.jsoup.examples.HtmlToPlainText url [selector]</code></p>
 * where <i>url</i> is the URL to fetch, and <i>selector</i> is an optional CSS selector.
 * 
 * @author Jonathan Hedley, jonathan@hedley.net
 */
public class HtmlToPlainText {
    private static final String userAgent = "Mozilla/5.0 (jsoup)";
    private static final int timeout = 5 * 1000;

    public static void main(String... args) throws IOException {
        Validate.isTrue(args.length == 1 || args.length == 2, "usage: java -cp jsoup.jar org.jsoup.examples.HtmlToPlainText url [selector]");
        final String url = args[0];
        final String selector = args.length == 2 ? args[1] : null;

        // fetch the specified URL and parse to a HTML DOM
        Document doc = Jsoup.connect(url).userAgent(userAgent).timeout(timeout).get();

        HtmlToPlainText formatter = new HtmlToPlainText();

        if (selector != null) {
            Elements elements = doc.select(selector); // get each element that matches the CSS selector
            for (Element element : elements) {
                String plainText = formatter.getPlainText(element); // format that element to plain text
                System.out.println(plainText);
            }
        } else { // format the whole doc
            String plainText = formatter.getPlainText(doc);
            System.out.println(plainText);
        }
    }

    /**
     * Format an Element to plain-text
     * @param element the root element to format
     * @return formatted text
     */
    public String getPlainText(Element element) {
        FormattingVisitor formatter = new FormattingVisitor();
        NodeTraversor traversor = new NodeTraversor(formatter);
        traversor.traverse(element); // walk the DOM, and call .head() and .tail() for each node

        return formatter.toString();
    }

    // the formatting rules, implemented in a breadth-first DOM traverse
    private class FormattingVisitor implements NodeVisitor {
        private static final int maxWidth = 80;
        private int width = 0;
        private StringBuilder accum = new StringBuilder(); // holds the accumulated text

        // hit when the node is first seen
        public void head(Node node, int depth) {
            String name = node.nodeName();
            if (node instanceof TextNode)
                append(((TextNode) node).text()); // TextNodes carry all user-readable text in the DOM.
            else if (name.equals("li"))
                append("\n * ");
            else if (name.equals("dt"))
                append("  ");
            else if (StringUtil.in(name, "p", "h1", "h2", "h3", "h4", "h5", "tr"))
                append("\n");
        }

        // hit when all of the node's children (if any) have been visited
        public void tail(Node node, int depth) {
            String name = node.nodeName();
            if (StringUtil.in(name, "br", "dd", "dt", "p", "h1", "h2", "h3", "h4", "h5"))
                append("\n");
            else if (name.equals("a"))
                append(String.format(" <%s>", node.absUrl("href")));
        }

        // appends text to the string builder with a simple word wrap method
        private void append(String text) {
            if (text.startsWith("\n"))
                width = 0; // reset counter if starts with a newline. only from formats above, not in natural text
            if (text.equals(" ") &&
                    (accum.length() == 0 || StringUtil.in(accum.substring(accum.length() - 1), " ", "\n")))
                return; // don't accumulate long runs of empty spaces

            if (text.length() + width > maxWidth) { // won't fit, needs to wrap
                String words[] = text.split("\\s+");
                for (int i = 0; i < words.length; i++) {
                    String word = words[i];
                    boolean last = i == words.length - 1;
                    if (!last) // insert a space if not the last word
                        word = word + " ";
                    if (word.length() + width > maxWidth) { // wrap and reset counter
                        accum.append("\n").append(word);
                        width = word.length();
                    } else {
                        accum.append(word);
                        width += word.length();
                    }
                }
            } else { // fits as is, without need to wrap text
                accum.append(text);
                width += text.length();
            }
        }

        @Override
        public String toString() {
            return accum.toString();
        }
    }
}

- Malcolm Smith

这种方法相对于简单的 Element.wholeText 的优势在于它可以提取 href 链接。 - Dario Seidl

4

text = Jsoup.parse(html.replaceAll("(?i)<br[^>]*>", "br2n")).text();
text = descrizione.replaceAll("br2n", "\n");

如果HTML本身不包含"br2n"，那么这个方法是有效的。

因此，

text = Jsoup.parse(html.replaceAll("(?i)<br[^>]*>", "<pre>\n</pre>")).text();

让工作更可靠、更易于操作。

- Green Beret

3

使用jsoup试试这个：

    doc.outputSettings(new OutputSettings().prettyPrint(false));

    //select all <br> tags and append \n after that
    doc.select("br").after("\\n");

    //select all <p> tags and prepend \n before that
    doc.select("p").before("\\n");

    //get the HTML from the document, and retaining original new lines
    String str = doc.html().replaceAll("\\\\n", "\n");

- Abhay Gupta

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- user121196 · Accepted Answer

保留换行符的真正解决方案应该像这样：

public static String br2nl(String html) {
    if(html==null)
        return html;
    Document document = Jsoup.parse(html);
    document.outputSettings(new Document.OutputSettings().prettyPrint(false));//makes html() preserve linebreaks and spacing
    document.select("br").append("\\n");
    document.select("p").prepend("\\n\\n");
    String s = document.html().replaceAll("\\\\n", "\n");
    return Jsoup.clean(s, "", Whitelist.none(), new Document.OutputSettings().prettyPrint(false));
}

它满足以下要求：

如果原始的html包含换行符(\n)，则保留
如果原始的html包含br或p标签，则转换为换行符(\n)。