Extrahujte obsah mezi uzly v dokumentu

Při práci s dokumenty je důležité být schopen snadno extrahovat obsah z konkrétního rozsahu v dokumentu. Obsah však může sestávat ze složitých prvků, jako jsou odstavce, tabulky, obrázky atd.

Bez ohledu na to, jaký obsah je třeba extrahovat, bude metoda extrahování tohoto obsahu vždy určena podle toho, které uzly jsou vybrány k extrahování obsahu mezi nimi. Mohou to být celá textová těla nebo jednoduché textové běhy.

Existuje mnoho možných situací, a proto je třeba při extrahování obsahu zvážit mnoho různých typů uzlů. Můžete například chtít extrahovat obsah mezi:

Dva konkrétní odstavce
Konkrétní běhy textu
Pole různých typů, například sloučit pole
Počáteční a koncový rozsah záložky nebo komentáře
Různá těla textu obsažená v samostatných částech

V některých situacích může být dokonce nutné kombinovat různé typy uzlů, například extrahování obsahu mezi odstavcem a polem nebo mezi spuštěním a záložkou.

Tento článek poskytuje implementaci kódu pro extrahování textu mezi různými uzly, stejně jako příklady běžných scénářů.

Tyto příklady jsou jen několika ukázkami mnoha možností. V budoucnu plánujeme, aby funkce extrakce textu byla součástí veřejné API a nebude vyžadován žádný další kód. Mezitím můžete své požadavky týkající se této funkce zveřejnit na Aspose.Words fórum.

Proč Extrahovat Obsah

Cílem extrahování obsahu je často duplikovat nebo uložit jej samostatně do nového dokumentu. Můžete například extrahovat obsah a:

Zkopírujte jej do samostatného dokumentu
Převod konkrétní části dokumentu na PDF nebo obrázek
Duplikujte obsah v dokumentu mnohokrát
Práce s extrahovaným obsahem odděleně od zbytku dokumentu

Toho lze snadno dosáhnout pomocí Aspose.Words a implementace kódu níže.

Extrahování Algoritmu Obsahu

Kód v této části řeší všechny možné situace popsané výše jednou zobecněnou a opakovaně použitelnou metodou. Obecný nástin této techniky zahrnuje:

Shromažďování uzlů, které diktují oblast obsahu, která bude extrahována z vašeho dokumentu. Načítání těchto uzlů zpracovává uživatel ve svém kódu na základě toho, co chtějí extrahovat.
Předání těchto uzlů metodě ExtractContent uvedené níže. Musíte také předat booleovský parametr, který uvádí, zda by tyto uzly, které fungují jako značky, měly být zahrnuty do extrakce nebo ne.
Načtení seznamu klonovaného obsahu (zkopírovaných uzlů) určeného k extrahování. Tento seznam uzlů můžete použít jakýmkoli použitelným způsobem, například vytvořením nového dokumentu obsahujícího pouze vybraný obsah.

Jak extrahovat obsah

Chcete-li extrahovat obsah z dokumentu, musíte zavolat metodu ExtractContent níže a předat příslušné parametry. Základem této metody je nalezení uzlů na úrovni bloků (odstavců a tabulek) a jejich klonování za účelem vytvoření identických kopií. Pokud jsou předané značkovací uzly na úrovni bloku, pak je metoda schopna jednoduše zkopírovat obsah na této úrovni a přidat jej do pole.

Pokud jsou však uzly značky Vložené (podřízené odstavci), situace se stává složitější, protože je nutné rozdělit odstavec na vloženém uzlu, ať už jde o Běh, Pole záložek atd. Obsah v klonovaných nadřazených uzlech, které nejsou přítomny mezi značkami, je odstraněn. Tento proces se používá k zajištění toho, aby Vložené uzly stále zachovaly formátování nadřazeného odstavce. Metoda také spustí kontroly uzlů předaných jako parametry a vyvolá výjimku, pokud je některý uzel neplatný. Parametry, které mají být předány této metodě, jsou:

StartNode a EndNode. První dva parametry jsou uzly, které definují, kde má extrakce obsahu začít a končit v příslušně. Tyto uzly mohou být jak na úrovni bloku (odstavec, tabulka), tak na úrovni inline (např. Run, FieldStart, BookmarkStart atd.):
1. Chcete-li předat pole, měli byste předat odpovídající objekt FieldStart.
2. Chcete-li předat záložky, měly by být předány uzly BookmarkStart a BookmarkEnd.
3. Pro předávání komentářů by měly být použity uzly CommentRangeStart a CommentRangeEnd.
IsInclusive. Definuje, zda jsou značky zahrnuty do extrakce nebo ne. Pokud je tato možnost nastavena na hodnotu false a je předán stejný uzel nebo po sobě jdoucí uzly, bude vrácen prázdný seznam:
1. Pokud je předán uzel FieldStart, pak tato volba definuje, zda má být celé pole zahrnuto nebo vyloučeno.
2. Pokud je předán uzel BookmarkStart nebo BookmarkEnd, Tato volba definuje, zda je záložka zahrnuta nebo pouze obsah mezi rozsahem záložek.
3. Pokud je předán uzel CommentRangeStart nebo CommentRangeEnd, Tato volba definuje, zda má být zahrnut samotný komentář nebo pouze obsah v rozsahu komentářů.

Implementaci metody ExtractContent můžete najít nízko. Tato metoda bude uvedena ve scénářích v tomto článku.

Definujeme také vlastní metodu pro snadné generování dokumentu z extrahovaných uzlů. Tato metoda se používá v mnoha níže uvedených scénářích a jednoduše vytvoří nový dokument a importuje do něj extrahovaný obsah.

Následující příklad kódu ukazuje, jak vzít seznam uzlů a vloží je do nového dokumentu.

	// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
	static SharedPtr<Document> GenerateDocument(SharedPtr<Document> srcDoc, SharedPtr<System::Collections::Generic::List<SharedPtr<Node>>> nodes)
	{
	auto dstDoc = MakeObject<Document>();
	// Remove the first paragraph from the empty document.
	dstDoc->get_FirstSection()->get_Body()->RemoveAllChildren();

	// Import each node from the list into the new document. Keep the original formatting of the node.
	auto importer = MakeObject<NodeImporter>(srcDoc, dstDoc, ImportFormatMode::KeepSourceFormatting);
	for (const auto& node : nodes)
	{
	SharedPtr<Node> importNode = importer->ImportNode(node, true);
	dstDoc->get_FirstSection()->get_Body()->AppendChild(importNode);
	}

	return dstDoc;
	}

view raw generate-document.h hosted with ❤ by GitHub

Extrahujte Obsah Mezi Odstavci

To ukazuje, jak použít výše uvedenou metodu k extrahování obsahu mezi konkrétními odstavci. V tomto případě chceme extrahovat tělo dopisu nalezeného v první polovině dokumentu. Můžeme říci, že je to mezi 7.a 11. odstavcem.

Níže uvedený kód splňuje tento úkol. Příslušné odstavce jsou extrahovány metodou GetChild v dokumentu a předáním zadaných indexů. Poté tyto uzly předáme metodě ExtractContent a uvedeme, že mají být zahrnuty do extrakce. Tato metoda vrátí zkopírovaný obsah mezi těmito uzly, které jsou poté vloženy do nového dokumentu.

Následující příklad kódu ukazuje, jak extrahovat obsah mezi konkrétními odstavci pomocí výše uvedené metody ExtractContent:

	// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
	auto doc = MakeObject<Document>(MyDir + u"Extract content.docx");

	auto startPara = System::ExplicitCast<Paragraph>(doc->get_FirstSection()->get_Body()->GetChild(NodeType::Paragraph, 6, true));
	auto endPara = System::ExplicitCast<Paragraph>(doc->get_FirstSection()->get_Body()->GetChild(NodeType::Paragraph, 10, true));
	// Extract the content between these nodes in the document. Include these markers in the extraction.
	SharedPtr<System::Collections::Generic::List<SharedPtr<Node>>> extractedNodes = ExtractContentHelper::ExtractContent(startPara, endPara, true);

	SharedPtr<Document> dstDoc = ExtractContentHelper::GenerateDocument(doc, extractedNodes);
	dstDoc->Save(ArtifactsDir + u"ExtractContent.ExtractContentBetweenParagraphs.docx");

view raw extract-content-between-paragraphs.h hosted with ❤ by GitHub

Extrahujte obsah mezi různými typy uzlů

Můžeme extrahovat obsah mezi libovolnými kombinacemi blokových nebo vložených uzlů. V tomto scénáři níže extrahujeme obsah mezi prvním odstavcem a tabulkou ve druhé části včetně. Uzly značek získáme voláním metody Body.FirstParagraph a GetChild ve druhé části dokumentu pro načtení příslušných uzlů odstavců a tabulek. Pro malou variaci místo toho duplikujte obsah a vložte jej pod originál.

Následující příklad kódu ukazuje, jak extrahovat obsah mezi odstavcem a tabulkou pomocí metody ExtractContent:

	// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
	auto doc = MakeObject<Document>(MyDir + u"Extract content.docx");

	auto startPara = System::ExplicitCast<Paragraph>(doc->get_LastSection()->GetChild(NodeType::Paragraph, 2, true));
	auto endTable = System::ExplicitCast<Table>(doc->get_LastSection()->GetChild(NodeType::Table, 0, true));
	// Extract the content between these nodes in the document. Include these markers in the extraction.
	SharedPtr<System::Collections::Generic::List<SharedPtr<Node>>> extractedNodes = ExtractContentHelper::ExtractContent(startPara, endTable, true);

	// Let's reverse the array to make inserting the content back into the document easier.
	extractedNodes->Reverse();
	for (SharedPtr<Node> extractedNode : extractedNodes)
	// Insert the last node from the reversed list.
	endTable->get_ParentNode()->InsertAfter(extractedNode, endTable);

	doc->Save(ArtifactsDir + u"ExtractContent.ExtractContentBetweenBlockLevelNodes.docx");

view raw extract-content-between-block-level-nodes.h hosted with ❤ by GitHub

Extrahujte obsah mezi odstavci na základě stylu

Možná budete muset extrahovat obsah mezi odstavci stejných nebo různých stylů, například mezi odstavci označenými styly nadpisů. Níže uvedený kód ukazuje, jak toho dosáhnout. Jedná se o jednoduchý příklad, který extrahuje obsah mezi první instancí stylů “Heading 1” a “Header 3” bez extrahování nadpisů. Za tímto účelem nastavíme poslední parametr na false, který určuje, že uzly značky by neměly být zahrnuty.

Při správné implementaci by to mělo být spuštěno ve smyčce pro extrahování obsahu mezi všemi odstavci těchto stylů z dokumentu. Extrahovaný obsah se zkopíruje do nového dokumentu.

Následující příklad kódu ukazuje, jak extrahovat obsah mezi odstavci se specifickými styly pomocí metody ExtractContent:

	// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
	auto doc = MakeObject<Document>(MyDir + u"Extract content.docx");

	// Gather a list of the paragraphs using the respective heading styles.
	SharedPtr<System::Collections::Generic::List<SharedPtr<Paragraph>>> parasStyleHeading1 = ParagraphsByStyleName(doc, u"Heading 1");
	SharedPtr<System::Collections::Generic::List<SharedPtr<Paragraph>>> parasStyleHeading3 = ParagraphsByStyleName(doc, u"Heading 3");

	// Use the first instance of the paragraphs with those styles.
	SharedPtr<Node> startPara1 = parasStyleHeading1->idx_get(0);
	SharedPtr<Node> endPara1 = parasStyleHeading3->idx_get(0);

	// Extract the content between these nodes in the document. Don't include these markers in the extraction.
	SharedPtr<System::Collections::Generic::List<SharedPtr<Node>>> extractedNodes = ExtractContentHelper::ExtractContent(startPara1, endPara1, false);

	SharedPtr<Document> dstDoc = ExtractContentHelper::GenerateDocument(doc, extractedNodes);
	dstDoc->Save(ArtifactsDir + u"ExtractContent.ExtractContentBetweenParagraphStyles.docx");

view raw extract-content-between-paragraph-styles.h hosted with ❤ by GitHub

	// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
	static SharedPtr<System::Collections::Generic::List<SharedPtr<Paragraph>>> ParagraphsByStyleName(SharedPtr<Document> doc, System::String styleName)
	{
	// Create an array to collect paragraphs of the specified style.
	SharedPtr<System::Collections::Generic::List<SharedPtr<Paragraph>>> paragraphsWithStyle =
	MakeObject<System::Collections::Generic::List<SharedPtr<Paragraph>>>();

	SharedPtr<NodeCollection> paragraphs = doc->GetChildNodes(NodeType::Paragraph, true);

	// Look through all paragraphs to find those with the specified style.
	for (const auto& paragraph : System::IterateOver<Paragraph>(paragraphs))
	{
	if (paragraph->get_ParagraphFormat()->get_Style()->get_Name() == styleName)
	{
	paragraphsWithStyle->Add(paragraph);
	}
	}

	return paragraphsWithStyle;
	}

view raw paragraphs-by-style-name.h hosted with ❤ by GitHub

Extrahujte Obsah Mezi Konkrétními Běhy

Můžete také extrahovat obsah mezi vloženými uzly, například Run. Runs z různých odstavců lze předat jako značky. Níže uvedený kód ukazuje, jak extrahovat konkrétní text mezi stejným uzlem Paragraph.

Následující příklad kódu ukazuje, jak extrahovat obsah mezi konkrétními běhy stejného odstavce pomocí metody ExtractContent:

	// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
	auto doc = MakeObject<Document>(MyDir + u"Extract content.docx");

	auto para = System::ExplicitCast<Paragraph>(doc->GetChild(NodeType::Paragraph, 7, true));
	SharedPtr<Run> startRun = para->get_Runs()->idx_get(1);
	SharedPtr<Run> endRun = para->get_Runs()->idx_get(4);

	// Extract the content between these nodes in the document. Include these markers in the extraction.
	SharedPtr<System::Collections::Generic::List<SharedPtr<Node>>> extractedNodes = ExtractContentHelper::ExtractContent(startRun, endRun, true);

	for (SharedPtr<Node> extractedNode : extractedNodes)
	std::cout << extractedNode->ToString(SaveFormat::Text) << std::endl;

view raw extract-content-between-runs.h hosted with ❤ by GitHub

Extrahujte obsah pomocí pole

Chcete-li použít pole jako značku, měl by být předán uzel FieldStart. Poslední parametr metody ExtractContent definuje, zda má být celé pole zahrnuto nebo ne. Extrahujme obsah mezi slučovacím polem “FullName " a odstavcem v dokumentu. Používáme metodu MoveToMergeField třídy DocumentBuilder. Tím se vrátí uzel FieldStart z pole Název sloučení, které mu bylo předáno.

V našem případě nastavíme poslední parametr předaný metodě ExtractContent na false, abychom vyloučili pole z extrakce. Extrahovaný obsah vykreslíme do PDF.

Následující příklad kódu ukazuje, jak extrahovat obsah mezi konkrétním polem a odstavcem v dokumentu pomocí metody ExtractContent:

	// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
	auto doc = MakeObject<Document>(MyDir + u"Extract content.docx");
	auto builder = MakeObject<DocumentBuilder>(doc);

	// Pass the first boolean parameter to get the DocumentBuilder to move to the FieldStart of the field.
	// We could also get FieldStarts of a field using GetChildNode method as in the other examples.
	builder->MoveToMergeField(u"Fullname", false, false);

	// The builder cursor should be positioned at the start of the field.
	auto startField = System::ExplicitCast<FieldStart>(builder->get_CurrentNode());
	auto endPara = System::ExplicitCast<Paragraph>(doc->get_FirstSection()->GetChild(NodeType::Paragraph, 5, true));

	// Extract the content between these nodes in the document. Don't include these markers in the extraction.
	SharedPtr<System::Collections::Generic::List<SharedPtr<Node>>> extractedNodes = ExtractContentHelper::ExtractContent(startField, endPara, false);

	SharedPtr<Document> dstDoc = ExtractContentHelper::GenerateDocument(doc, extractedNodes);
	dstDoc->Save(ArtifactsDir + u"ExtractContent.ExtractContentUsingField.docx");

view raw extract-content-using-field.h hosted with ❤ by GitHub

Extrahujte obsah ze záložky

V dokumentu je obsah definovaný v záložce zapouzdřen uzly BookmarkStart a BookmarkEnd. Obsah nalezený mezi těmito dvěma uzly tvoří záložku. Kterýkoli z těchto uzlů můžete předat jako jakoukoli značku, dokonce i ty z různých záložek, pokud se počáteční značka objeví před koncovou značkou v dokumentu. Tento obsah extrahujeme do nového dokumentu pomocí níže uvedeného kódu. Volba parametru IsInclusive ukazuje, jak záložku zachovat nebo zahodit.

Následující příklad kódu ukazuje, jak extrahovat obsah odkazovaný na záložku pomocí metody ExtractContent:

	// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
	auto doc = MakeObject<Document>(MyDir + u"Extract content.docx");

	SharedPtr<Bookmark> bookmark = doc->get_Range()->get_Bookmarks()->idx_get(u"Bookmark1");
	SharedPtr<BookmarkStart> bookmarkStart = bookmark->get_BookmarkStart();
	SharedPtr<BookmarkEnd> bookmarkEnd = bookmark->get_BookmarkEnd();

	// Firstly, extract the content between these nodes, including the bookmark.
	SharedPtr<System::Collections::Generic::List<SharedPtr<Node>>> extractedNodesInclusive =
	ExtractContentHelper::ExtractContent(bookmarkStart, bookmarkEnd, true);

	SharedPtr<Document> dstDoc = ExtractContentHelper::GenerateDocument(doc, extractedNodesInclusive);
	dstDoc->Save(ArtifactsDir + u"ExtractContent.ExtractContentBetweenBookmark.IncludingBookmark.docx");

	// Secondly, extract the content between these nodes this time without including the bookmark.
	SharedPtr<System::Collections::Generic::List<SharedPtr<Node>>> extractedNodesExclusive =
	ExtractContentHelper::ExtractContent(bookmarkStart, bookmarkEnd, false);

	dstDoc = ExtractContentHelper::GenerateDocument(doc, extractedNodesExclusive);
	dstDoc->Save(ArtifactsDir + u"ExtractContent.ExtractContentBetweenBookmark.WithoutBookmark.docx");

view raw extract-content-between-bookmark.h hosted with ❤ by GitHub

Extrahujte obsah z Komentáře

Komentář se skládá z uzlů CommentRangeStart, CommentRangeEnd a komentářů. Všechny tyto uzly jsou vložené. První dva uzly zapouzdřují obsah v dokumentu, na který odkazuje komentář, jak je vidět na obrázku níže.

Samotný uzel Comment je InlineStory, který může obsahovat odstavce a běhy. Představuje zprávu Komentáře, která je v podokně náhledu vnímána jako bublina komentářů. Protože je tento uzel vložený a potomek těla, můžete také extrahovat obsah z této zprávy.

Komentář zapouzdřuje Nadpis, první odstavec a tabulku ve druhé části. Pojďme extrahovat tento komentář do nového dokumentu. Volba IsInclusive určuje, zda je samotný komentář zachován nebo zahozen.

Následující příklad kódu ukazuje, jak to udělat:

	// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
	auto doc = MakeObject<Document>(MyDir + u"Extract content.docx");

	auto commentStart = System::ExplicitCast<CommentRangeStart>(doc->GetChild(NodeType::CommentRangeStart, 0, true));
	auto commentEnd = System::ExplicitCast<CommentRangeEnd>(doc->GetChild(NodeType::CommentRangeEnd, 0, true));

	// Firstly, extract the content between these nodes including the comment as well.
	SharedPtr<System::Collections::Generic::List<SharedPtr<Node>>> extractedNodesInclusive =
	ExtractContentHelper::ExtractContent(commentStart, commentEnd, true);

	SharedPtr<Document> dstDoc = ExtractContentHelper::GenerateDocument(doc, extractedNodesInclusive);
	dstDoc->Save(ArtifactsDir + u"ExtractContent.ExtractContentBetweenCommentRange.IncludingComment.docx");

	// Secondly, extract the content between these nodes without the comment.
	SharedPtr<System::Collections::Generic::List<SharedPtr<Node>>> extractedNodesExclusive =
	ExtractContentHelper::ExtractContent(commentStart, commentEnd, false);

	dstDoc = ExtractContentHelper::GenerateDocument(doc, extractedNodesExclusive);
	dstDoc->Save(ArtifactsDir + u"ExtractContent.ExtractContentBetweenCommentRange.WithoutComment.docx");

view raw extract-content-between-comment-range.h hosted with ❤ by GitHub

Jak extrahovat obsah pomocí DocumentVisitor

K implementaci tohoto scénáře použití použijte třídu DocumentVisitor. Tato třída odpovídá známému vzoru designu návštěvníků. Pomocí DocumentVisitor, můžete definovat a provádět vlastní operace, které vyžadují výčet nad stromem dokumentů.

DocumentVisitor

Každá metoda DocumentVisitor.VisitXXX vrací hodnotu VisitorAction, která řídí výčet uzlů. Můžete požádat o pokračování výčtu, přeskočení aktuálního uzlu (ale pokračování výčtu) nebo zastavení výčtu uzlů.

Toto jsou kroky, které byste měli dodržovat, abyste programově určili a extrahovali různé části dokumentu:

Vytvořte třídu odvozenou od DocumentVisitor
Přepsat a poskytnout implementace pro některé nebo všechny metody DocumentVisitor.VisitXXX k provádění některých vlastních operací
Zavolejte Node.Accept na uzel, odkud chcete spustit výčet. Pokud například chcete vyčíslit celý dokument, použijte Document.Accept

DocumentVisitor

Tento příklad ukazuje, jak použít vzor návštěvníka k přidání nových operací do objektového modelu Aspose.Words. V tomto případě vytvoříme jednoduchý převodník dokumentů do textového formátu:

	// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
	auto doc = MakeObject<Document>(MyDir + u"Extract content.docx");

	auto convertToPlainText = MakeObject<ExtractContent::ConvertDocToTxt>();
	// Note that every node in the object model has the accept method so the visiting
	// can be executed not only for the whole document, but for any node in the document.
	doc->Accept(convertToPlainText);

	// Once the visiting is complete, we can retrieve the result of the operation,
	// That in this example, has accumulated in the visitor.
	std::cout << convertToPlainText->GetText() << std::endl;

view raw extract-content-using-document-visitor.h hosted with ❤ by GitHub

	// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
	/// <summary>
	/// Simple implementation of saving a document in the plain text format. Implemented as a Visitor.
	/// </summary>
	class ConvertDocToTxt : public DocumentVisitor
	{
	public:
	ConvertDocToTxt() : mIsSkipText(false)
	{
	mIsSkipText = false;
	mBuilder = MakeObject<System::Text::StringBuilder>();
	}

	/// <summary>
	/// Gets the plain text of the document that was accumulated by the visitor.
	/// </summary>
	String GetText()
	{
	return mBuilder->ToString();
	}

	/// <summary>
	/// Called when a Run node is encountered in the document.
	/// </summary>
	VisitorAction VisitRun(SharedPtr<Run> run) override
	{
	AppendText(run->get_Text());
	// Let the visitor continue visiting other nodes.
	return VisitorAction::Continue;
	}

	/// <summary>
	/// Called when a FieldStart node is encountered in the document.
	/// </summary>
	VisitorAction VisitFieldStart(SharedPtr<FieldStart> fieldStart) override
	{
	ASPOSE_UNUSED(fieldStart);
	// In Microsoft Word, a field code (such as "MERGEFIELD FieldName") follows
	// after a field start character. We want to skip field codes and output field.
	// Result only, therefore we use a flag to suspend the output while inside a field code.
	// Note this is a very simplistic implementation and will not work very well.
	// If you have nested fields in a document.
	mIsSkipText = true;
	return VisitorAction::Continue;
	}

	/// <summary>
	/// Called when a FieldSeparator node is encountered in the document.
	/// </summary>
	VisitorAction VisitFieldSeparator(SharedPtr<FieldSeparator> fieldSeparator) override
	{
	ASPOSE_UNUSED(fieldSeparator);
	// Once reached a field separator node, we enable the output because we are
	// now entering the field result nodes.
	mIsSkipText = false;
	return VisitorAction::Continue;
	}

	/// <summary>
	/// Called when a FieldEnd node is encountered in the document.
	/// </summary>
	VisitorAction VisitFieldEnd(SharedPtr<FieldEnd> fieldEnd) override
	{
	ASPOSE_UNUSED(fieldEnd);
	// Make sure we enable the output when reached a field end because some fields
	// do not have field separator and do not have field result.
	mIsSkipText = false;
	return VisitorAction::Continue;
	}

	/// <summary>
	/// Called when visiting of a Paragraph node is ended in the document.
	/// </summary>
	VisitorAction VisitParagraphEnd(SharedPtr<Paragraph> paragraph) override
	{
	ASPOSE_UNUSED(paragraph);
	// When outputting to plain text we output Cr+Lf characters.
	AppendText(ControlChar::CrLf());
	return VisitorAction::Continue;
	}

	VisitorAction VisitBodyStart(SharedPtr<Body> body) override
	{
	ASPOSE_UNUSED(body);
	// We can detect beginning and end of all composite nodes such as Section, Body,
	// Table, Paragraph etc and provide custom handling for them.
	mBuilder->Append(u"* Body Started *\r\n");
	return VisitorAction::Continue;
	}

	VisitorAction VisitBodyEnd(SharedPtr<Body> body) override
	{
	ASPOSE_UNUSED(body);
	mBuilder->Append(u"* Body Ended *\r\n");
	return VisitorAction::Continue;
	}

	/// <summary>
	/// Called when a HeaderFooter node is encountered in the document.
	/// </summary>
	VisitorAction VisitHeaderFooterStart(SharedPtr<HeaderFooter> headerFooter) override
	{
	ASPOSE_UNUSED(headerFooter);
	// Returning this value from a visitor method causes visiting of this
	// Node to stop and move on to visiting the next sibling node
	// The net effect in this example is that the text of headers and footers
	// Is not included in the resulting output
	return VisitorAction::SkipThisNode;
	}

	private:
	SharedPtr<System::Text::StringBuilder> mBuilder;
	bool mIsSkipText;

	/// <summary>
	/// Adds text to the current output. Honors the enabled/disabled output flag.
	/// </summary>
	void AppendText(String text)
	{
	if (!mIsSkipText)
	{
	mBuilder->Append(text);
	}
	}
	};

view raw convert-doc-to-txt.h hosted with ❤ by GitHub

Ukázkový soubor tohoto příkladu si můžete stáhnout z Aspose.Words GitHub.

Jak extrahovat pouze Text

Způsoby načítání textu z dokumentu jsou:

Použijte Document.Save s SaveFormat.Text k uložení jako prostý text do souboru nebo streamu
Použijte Node.ToString a předejte parametr SaveFormat.Text. Interně to vyvolá uložit jako text do proudu paměti a vrátí výsledný řetězec
Použijte Node.GetText k načtení textu se všemi řídicími znaky Microsoft Word včetně kódů polí
Implementujte vlastní DocumentVisitor k provedení přizpůsobené extrakce

Použití `Node.GetText` a `Node.ToString`

Word dokument může obsahovat kontrolní znaky, které označují speciální prvky, jako je pole,Konec buňky, konec sekce atd. Úplný seznam možných řídicích znaků Word je definován ve třídě ControlChar. Metoda Node.GetText vrací text se všemi znaky řídicího znaku přítomnými v uzlu.

Volání ToString vrátí prostou textovou reprezentaci dokumentu pouze bez ovládacích znaků.

Následující příklad kódu ukazuje rozdíl mezi voláním metod GetText a ToString v uzlu:

	// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
	auto doc = MakeObject<Document>();
	auto builder = MakeObject<DocumentBuilder>(doc);

	builder->InsertField(u"MERGEFIELD Field");

	// When converted to text it will not retrieve fields code or special characters,
	// but will still contain some natural formatting characters such as paragraph markers etc.
	// This is the same as "viewing" the document as if it was opened in a text editor.
	std::cout << (String(u"ToString() Result: ") + doc->ToString(SaveFormat::Text)) << std::endl;

view raw simple-extract-text.h hosted with ❤ by GitHub

Použití `SaveFormat.Text`

Tento příklad uloží dokument následujícím způsobem:

Filtruje znaky polí a kódy polí, tvar, poznámky pod čarou, vysvětlivky a komentáře
Nahrazuje znaky konce odstavce ControlChar.Cr kombinací ControlChar.CrLf
Používá UTF8 kódování

Následující příklad kódu ukazuje, jak uložit dokument ve formátu TXT:

	// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
	auto doc = MakeObject<Document>(MyDir + u"Document.docx");
	doc->Save(ArtifactsDir + u"BaseConversions.DocxToTxt.txt");

view raw docx-to-txt.h hosted with ❤ by GitHub

Extrahujte obrázky z tvarů

Možná budete muset extrahovat obrázky dokumentů, abyste mohli provádět některé úkoly. Aspose.Words vám to také umožňuje.

Následující příklad kódu ukazuje, jak extrahovat obrázky z dokumentu:

	// For complete examples and data files, please go to https://github.com/aspose-words/Aspose.Words-for-C.git.
	auto doc = MakeObject<Document>(MyDir + u"Images.docx");

	SharedPtr<NodeCollection> shapes = doc->GetChildNodes(NodeType::Shape, true);
	int imageIndex = 0;

	for (const auto& shape : System::IterateOver<Shape>(shapes))
	{
	if (shape->get_HasImage())
	{
	String imageFileName =
	String::Format(u"Image.ExportImages.{0}_{1}", imageIndex, FileFormatUtil::ImageTypeToExtension(shape->get_ImageData()->get_ImageType()));

	// Note, if you have only an image (not a shape with a text and the image),
	// you can use shape->GetShapeRenderer()->Save(...) method to save the image.
	shape->get_ImageData()->Save(ArtifactsDir + imageFileName);
	imageIndex++;
	}
	}

view raw extract-images.h hosted with ❤ by GitHub

Práce s rozsahy v C++ Práce s záhlaví a zápatí v C++