এইচটিএমএলকে সরল পাঠ্যে রূপান্তর করতে jsoup ব্যবহার করার সময় আমি কীভাবে লাইন ব্রেকগুলি সংরক্ষণ করব?

Question 1

আমার কাছে নিম্নলিখিত কোড রয়েছে:

 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>আমি পার্স করা মার্কআপে যদি একটি থাকে তবে আমি আমার ফলাফলের আউটপুটটিতে কীভাবে একটি লাইন বিরতি পেতে পারি?

Question 2

লাইনব্রেকগুলি সংরক্ষণ করে এমন আসল সমাধানটি এর মতো হওয়া উচিত:

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

এটি নিম্নলিখিত প্রয়োজনীয়তাগুলি পূরণ করে:

যদি মূল এইচটিএমএলতে নতুন লাইন থাকে (\ n), এটি সংরক্ষণ করা হবে
যদি মূল এইচটিএমএলতে বিআর বা পি ট্যাগ থাকে তবে সেগুলিকে নতুন লাইনে অনুবাদ করা হবে () n)

Question 3

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

আমরা এই পদ্ধতিটি এখানে ব্যবহার করছি:

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

এটি পাস করার মাধ্যমে Whitelist.none()আমরা নিশ্চিত করে নিই যে সমস্ত এইচটিএমএল সরানো হয়েছে।

পাস্কিংয়ের মাধ্যমে new OutputSettings().prettyPrint(false)আমরা নিশ্চিত হয়েছি যে আউটপুটটি পুনরায় ফর্ম্যাট করা হয়নি এবং লাইন ব্রেকগুলি সংরক্ষণ করা হয়েছে।

Question 4

সঙ্গে

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

আপনার আউটপুট আছে

"A B"

এবং না

A

B

এর জন্য আমি ব্যবহার করছি:

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

Question 5

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

Question 6

Jsoup v1.11.2 এ, আমরা এখন ব্যবহার করতে পারি Element.wholeText()।

উদাহরণ কোড:

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

user121196's উত্তর এখনও কাজ করে। তবে wholeText()পাঠ্যগুলির সারিবদ্ধতা সংরক্ষণ করে।

Question 7

আরও জটিল এইচটিএমএলের জন্য উপরের সমাধানগুলির মধ্যে কোনওটিই ঠিক মতো কাজ করেনি; এর সাথে লাইন ব্রেকগুলি সংরক্ষণ করার সময় আমি সাফল্যের সাথে রূপান্তর করতে সক্ষম হয়েছি:

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

(সংস্করণ 1.10.3)

Question 8

আপনি একটি প্রদত্ত উপাদান অতিক্রম করতে পারেন

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

Question 9

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

এইচটিএমএল নিজেই "br2n" না থাকলে কাজ করে

সুতরাং,

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

আরও নির্ভরযোগ্য এবং সহজ কাজ করে।

Question 10

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");

Question 11

এটা চেষ্টা কর:

public String noTags(String str){
    Document d = Jsoup.parse(str);
    TextNode tn = new TextNode(d.body().html(), "");
    return tn.getWholeText();
}

Question 12

textNodes()পাঠ্য নোডগুলির একটি তালিকা পেতে ব্যবহার করুন । তারপরে তাদেরকে \nবিভাজক হিসাবে যুক্ত করুন। আমি এর জন্য কিছু স্কাল কোড ব্যবহার করছি, জাভা বন্দরটি সহজ হওয়া উচিত:

val rawTxt = doc.body().getElementsByTag("div").first.textNodes()
                    .asScala.mkString("<br />\n")

Question 13

অন্যান্য উত্তর এবং এই প্রশ্নের মন্তব্যের উপর ভিত্তি করে মনে হয় যে এখানে আসা বেশিরভাগ লোকেরা সত্যিই একটি সাধারণ সমাধান খুঁজছেন যা একটি HTML ডকুমেন্টের সুন্দর বিন্যাসিত সরল পাঠ্য উপস্থাপনা সরবরাহ করবে। আমি জানি আমি ছিলাম

ভাগ্যক্রমে JSoup এটি কীভাবে অর্জন করবেন তার ইতিমধ্যে একটি বিস্তৃত উদাহরণ প্রদান করেছেন: HtmlToPlainText.java

উদাহরণটি FormattingVisitorসহজেই আপনার পছন্দটিকে টুইট করতে পারে এবং বেশিরভাগ ব্লক উপাদানসমূহ এবং লাইন মোড়কের বিষয়ে কাজ করে।

লিঙ্ক পচা এড়াতে, এখানে জোনাথন হেডলির সম্পূর্ণ সমাধান রয়েছে:

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

Question 14

এটি আমার পাঠ্য থেকে এইচটিএমএল অনুবাদ করার সংস্করণ (ব্যবহারকারী 121196 উত্তরের পরিবর্তিত সংস্করণ, আসলে)।

এটি কেবল লাইন ব্রেকগুলি সংরক্ষণ করে না, তবে পাঠ্যকে ফর্ম্যাট করে এবং অতিরিক্ত লাইন বিরতি, এইচটিএমএল এস্কেপ প্রতীকগুলি সরিয়ে দেয় এবং আপনি আপনার এইচটিএমএল থেকে আরও ভাল ফলাফল পাবেন (আমার ক্ষেত্রে এটি আমি মেল থেকে পাচ্ছি)।

এটি মূলত স্কালায় লেখা হয়েছে তবে আপনি এটি সহজেই জাভাতে পরিবর্তন করতে পারেন

def html2text( rawHtml : String ) : String = {

    val htmlDoc = Jsoup.parseBodyFragment( rawHtml, "/" )
    htmlDoc.select("br").append("\\nl")
    htmlDoc.select("div").prepend("\\nl").append("\\nl")
    htmlDoc.select("p").prepend("\\nl\\nl").append("\\nl\\nl")

    org.jsoup.parser.Parser.unescapeEntities(
        Jsoup.clean(
          htmlDoc.html(),
          "",
          Whitelist.none(),
          new org.jsoup.nodes.Document.OutputSettings().prettyPrint(true)
        ),false
    ).
    replaceAll("\\\\nl", "\n").
    replaceAll("\r","").
    replaceAll("\n\\s+\n","\n").
    replaceAll("\n\n+","\n\n").     
    trim()      
}

Question 15

/**
 * Recursive method to replace html br with java \n. The recursive method ensures that the linebreaker can never end up pre-existing in the text being replaced.
 * @param html
 * @param linebreakerString
 * @return the html as String with proper java newlines instead of br
 */
public static String replaceBrWithNewLine(String html, String linebreakerString){
    String result = "";
    if(html.contains(linebreakerString)){
        result = replaceBrWithNewLine(html, linebreakerString+"1");
    } else {
        result = Jsoup.parse(html.replaceAll("(?i)<br[^>]*>", linebreakerString)).text(); // replace and html line breaks with java linebreak.
        result = result.replaceAll(linebreakerString, "\n");
    }
    return result;
}

অস্থায়ী নিউলাইন স্থানধারক হিসাবে আপনি যে স্ট্রিংটি ব্যবহার করতে চান তার পাশাপাশি, প্রশ্নযুক্ত এইচটিএমএলকে কল করে ব্যবহার করা হয়। উদাহরণ স্বরূপ:

replaceBrWithNewLine(element.html(), "br2n")

পুনরাবৃত্তিটি নিশ্চিত করবে যে আপনি যে স্ট্রিংটিকে নিউলাইন / লাইনব্রেকার স্থানধারক হিসাবে ব্যবহার করেন তা আসলে উত্স এইচটিএমএলে কখনই থাকবে না, কারণ এটি লিঙ্কব্রেকার স্থানধারক স্ট্রিংটি এইচটিএমএলে পাওয়া যায় না ততক্ষণ "1" যোগ করতে থাকবে। এটির ফর্ম্যাটিং ইস্যুটি নেই যা জসপ.প্লান পদ্ধতিগুলি বিশেষ অক্ষরের সাথে দেখা বলে মনে হচ্ছে।

Question 16

ব্যবহারকারী 121196 এর এবং গ্রীন বেরেটের selectএস এবং <pre>এস এর উত্তরের ভিত্তিতে , আমার পক্ষে কাজ করা একমাত্র সমাধান হ'ল:

org.jsoup.nodes.Element elementWithHtml = ....
elementWithHtml.select("br").append("<pre>\n</pre>");
elementWithHtml.select("p").prepend("<pre>\n\n</pre>");
elementWithHtml.text();