Краткое резюме (TL;DR):

• Одна или несколько гиперссылок: Нажмите правой кнопкой мыши на текст ссылки и выберите Удалить гиперссылку.

• Все гиперссылки в документе:

  • Windows: Нажмите Ctrl + A, затем Ctrl + Shift + F9.

  • Mac: Нажмите Cmd + A, затем Cmd + Shift + F9. Если клавиша F9 назначена системной функции macOS, используйте Cmd + Fn + Shift + F9 или нажмите Cmd + 6.

• Word не установлен: Используйте Word для интернета, чтобы удалить гиперссылки в браузере.

• Множество файлов Word: Используйте пакетную обработку на C# для автоматического удаления гиперссылок.

Гиперссылки полезны для обмена ссылками на веб-сайты, источники и другие ресурсы в документе Word. Однако при подготовке документа к печати, публикации или повторному использованию эти ссылки могут стать ненужными или оставить после себя нежелательное форматирование.

В этом руководстве показано, как удалять гиперссылки в Word: от удаления отдельных или всех ссылок в Microsoft Word до автоматизации очистки нескольких DOCX-файлов с помощью C#.

Что вы узнаете:

• Удаление гиперссылки в Microsoft Word
• Удаление всех гиперссылок в документе Word одновременно
• Удаление гиперссылок в Word Online
• Пакетное удаление гиперссылок из документов Word с помощью C#
• Бонус: Как запретить Word автоматически создавать гиперссылки
• Что проверить после удаления гиперссылок
• Часто задаваемые вопросы

Удаление гиперссылки в Microsoft Word

Лучший способ для: удаления одной или нескольких гиперссылок без влияния на остальное содержимое документа.

Если нужно удалить лишь небольшое количество ссылок, встроенная в Word команда Удалить гиперссылку является самым безопасным и простым вариантом. Она удаляет возможность перехода по ссылке, сохраняя при этом сам текст.

Этот метод особенно полезен в документах, содержащих оглавления, цитаты, перекрестные ссылки или другие динамические поля, так как затрагивается только выбранная гиперссылка.

Пошаговая инструкция

1. Откройте документ в Microsoft Word.

2. Найдите гиперссылку, которую хотите удалить.

3. Нажмите правой кнопкой мыши на текст ссылки.

4. Выберите Удалить гиперссылку.

   

Результат: Выбранный текст остается в документе, но перестает быть кликабельным.

⚡ Совет: Если вы хотите удалить и гиперссылку, и отображаемый текст, выделите текст и нажмите Delete или Backspace.

Удаление всех гиперссылок в документе Word одновременно

Лучший способ для: быстрого удаления множества гиперссылок из относительно простого документа Word.

Удаление десятков ссылок по одной отнимает много времени. В Word есть сочетание клавиш, которое позволяет убрать гиперссылки из выделенного фрагмента за одну операцию.

Удаление всех гиперссылок в Windows

1. Нажмите Ctrl + A, чтобы выделить все содержимое документа. Вы также можете вручную выделить только нужный фрагмент.

2. Нажмите Ctrl + Shift + F9.

Удаление всех гиперссылок на Mac

1. Нажмите Cmd + A, чтобы выделить содержимое документа.

2. Нажмите Cmd + Shift + F9.
   ⚡ Совет: Если на вашем Mac клавиша F9 используется для системных функций или медиа, используйте Cmd + Fn + Shift + F9 или нажмите Cmd + 6, чтобы запустить команду Word UnlinkFields без использования клавиши F9.

Результат: Все выбранные гиперссылки преобразуются в обычный текст с сохранением исходной формулировки.

⚠️ Важно: Проверьте динамические поля перед использованием этого сочетания клавиш

Ctrl + Shift + F9 — это не специфическая команда для гиперссылок. Это общая команда Word Разорвать связь с полем.

Это означает, что другие поля, включенные в выделение, также могут быть преобразованы в статический текст. К ним могут относиться:

• Автоматически созданные оглавления

• Перекрестные ссылки

• Поля цитат

• Другие динамические поля Word

Для отчетов, диссертаций, руководств и других документов, использующих динамические поля, сохраните резервную копию перед использованием этого сочетания клавиш. Также обратите внимание, что Ctrl + A обычно выделяет основной текст документа. Гиперссылки в колонтитулах, возможно, придется обрабатывать отдельно.

Удаление гиперссылок в Word Online

Лучший способ для: эпизодического удаления гиперссылок, когда настольная версия Microsoft Word недоступна.

Если у вас не установлен Word, вы можете открыть документ в Word для интернета, чтобы редактировать гиперссылки прямо в браузере. Это удобно для небольшого количества ссылок и не требует установки программного обеспечения.

Вариант А: Всплывающая панель инструментов (самый быстрый)

1. Нажмите на текст гиперссылки.

2. Нажмите на значок удаления ссылки (звено цепи с маленьким «X») в правой части всплывающей панели инструментов.

   

Вариант Б: Контекстное меню

1. Нажмите правой кнопкой мыши на текст гиперссылки.

2. Выберите Удалить гиперссылку в контекстном меню.

Не удается удалить гиперссылку в Word для интернета?

Некоторые ссылки в Word для интернета могут выглядеть серыми или быть недоступными для редактирования. Распространенные причины:

• Исправления: Ссылка была создана или изменена при включенном режиме отслеживания исправлений.

• Многоабзацные ссылки: Ссылка охватывает несколько абзацев и была создана в настольной версии Word.

Решение: Нажмите Открыть в классическом приложении (находится в выпадающем меню Редактирование на верхней ленте) и удалите ссылки в настольной версии Word.

Пакетное удаление гиперссылок из документов Word с помощью C#

Лучший способ для: разработчиков, автоматизирующих серверную обработку документов, очистку импортированных файлов или обработку больших коллекций документов Word.

Ручные методы становятся неэффективными, когда одну и ту же очистку нужно применить к множеству файлов Word. Это часто встречается при обработке импортированных документов, подготовке отчетов к публикации или архивированию, а также при очистке файлов, созданных другой системой.

В таких случаях удаление гиперссылок можно включить в рабочий процесс C#. В следующем примере используется Spire.Doc for .NET для пакетного удаления гиперссылок из нескольких DOCX-файлов без необходимости установки Microsoft Word.

Шаг 1: Установка библиотеки .NET Word

Установите Spire.Doc for .NET через NuGet, используя консоль диспетчера пакетов или .NET CLI.

Консоль диспетчера пакетов NuGet:

Install-Package Spire.Doc

.NET CLI:

dotnet add package Spire.Doc

После установки необходимые пространства имен можно использовать непосредственно в вашем проекте C#.

Шаг 2: Написание кода C# для пакетного удаления гиперссылок из DOCX-файлов

Следующий пример сканирует входную папку на наличие файлов .docx, идентифицирует поля гиперссылок в каждом документе, удаляет их, сохраняя отображаемый текст, и сохраняет обработанные файлы в отдельную выходную папку.

using Spire.Doc;
using Spire.Doc.Documents;
using Spire.Doc.Fields;
using System;
using System.Collections.Generic;
using System.Drawing;
using System.IO;

namespace Remove_Hyperlinks
{
    class Program
    {
        static void Main(string[] args)
        {
            string inputFolder = @"C:\WordFiles\Input";
            string outputFolder = @"C:\WordFiles\Output";

            // Создать выходную папку, если она не существует
            Directory.CreateDirectory(outputFolder);

            // Обработать все файлы DOCX во входной папке
            foreach (string inputFile in Directory.GetFiles(inputFolder, "*.docx"))
            {
                // Пропустить временные файлы Word
                if (Path.GetFileName(inputFile).StartsWith("~$"))
                    continue;

                // Создать экземпляр документа
                Document doc = new Document();

                // Загрузить документ Word
                doc.LoadFromFile(inputFile);

                // Найти все гиперссылки
                List<Field> hyperlinks = FindAllHyperlinks(doc);

                // «Сплющить» (удалить) все гиперссылки
                for (int i = hyperlinks.Count - 1; i >= 0; i--)
                {
                    FlattenHyperlinks(hyperlinks[i]);
                }

                // Сохранить обработанный документ
                string outputFile = Path.Combine(
                    outputFolder,
                    Path.GetFileName(inputFile));

                doc.SaveToFile(outputFile, FileFormat.Docx);
                doc.Close();

                Console.WriteLine(
                    $"Обработано: {Path.GetFileName(inputFile)}");
            }
        }

        // Получить все гиперссылки из тела документа
        private static List<Field> FindAllHyperlinks(Document document)
        {
            List<Field> hyperlinks = new List<Field>();

            foreach (Section section in document.Sections)
            {
                foreach (DocumentObject sec in section.Body.ChildObjects)
                {
                    if (sec.DocumentObjectType == DocumentObjectType.Paragraph)
                    {
                        foreach (DocumentObject para
                                 in (sec as Paragraph).ChildObjects)
                        {
                            if (para.DocumentObjectType ==
                                DocumentObjectType.Field)
                            {
                                Field field = para as Field;

                                if (field.Type == FieldType.FieldHyperlink)
                                {
                                    hyperlinks.Add(field);
                                }
                            }
                        }
                    }
                }
            }

            return hyperlinks;
        }

        // Удалить поле гиперссылки, сохранив отображаемый текст
        private static void FlattenHyperlinks(Field field)
        {
            int ownerParaIndex =
                field.OwnerParagraph.OwnerTextBody.ChildObjects
                    .IndexOf(field.OwnerParagraph);

            int fieldIndex =
                field.OwnerParagraph.ChildObjects.IndexOf(field);

            Paragraph sepOwnerPara =
                field.Separator.OwnerParagraph;

            int sepOwnerParaIndex =
                field.Separator.OwnerParagraph.OwnerTextBody.ChildObjects
                    .IndexOf(field.Separator.OwnerParagraph);

            int sepIndex =
                field.Separator.OwnerParagraph.ChildObjects
                    .IndexOf(field.Separator);

            int endIndex =
                field.End.OwnerParagraph.ChildObjects
                    .IndexOf(field.End);

            int endOwnerParaIndex =
                field.End.OwnerParagraph.OwnerTextBody.ChildObjects
                    .IndexOf(field.End.OwnerParagraph);

            FormatFieldResultText(
                field.Separator.OwnerParagraph.OwnerTextBody,
                sepOwnerParaIndex,
                endOwnerParaIndex,
                sepIndex,
                endIndex);

            // Удалить маркер конца поля
            field.End.OwnerParagraph.ChildObjects.RemoveAt(endIndex);

            // Удалить код поля и разделитель
            for (int i = sepOwnerParaIndex; i >= ownerParaIndex; i--)
            {
                if (i == sepOwnerParaIndex && i == ownerParaIndex)
                {
                    for (int j = sepIndex; j >= fieldIndex; j--)
                    {
                        field.OwnerParagraph.ChildObjects.RemoveAt(j);
                    }
                }
                else if (i == ownerParaIndex)
                {
                    for (int j =
                            field.OwnerParagraph.ChildObjects.Count - 1;
                         j >= fieldIndex;
                         j--)
                    {
                        field.OwnerParagraph.ChildObjects.RemoveAt(j);
                    }
                }
                else if (i == sepOwnerParaIndex)
                {
                    for (int j = sepIndex; j >= 0; j--)
                    {
                        sepOwnerPara.ChildObjects.RemoveAt(j);
                    }
                }
                else
                {
                    field.OwnerParagraph.OwnerTextBody.ChildObjects
                        .RemoveAt(i);
                }
            }
        }

        // Установить цвет текста гиперссылки в черный и удалить подчеркивание
        private static void FormatFieldResultText(
            Body ownerBody,
            int sepOwnerParaIndex,
            int endOwnerParaIndex,
            int sepIndex,
            int endIndex)
        {
            for (int i = sepOwnerParaIndex;
                 i <= endOwnerParaIndex;
                 i++)
            {
                Paragraph para =
                    ownerBody.ChildObjects[i] as Paragraph;

                if (i == sepOwnerParaIndex &&
                    i == endOwnerParaIndex)
                {
                    for (int j = sepIndex + 1; j < endIndex; j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
                else if (i == sepOwnerParaIndex)
                {
                    for (int j = sepIndex + 1;
                         j < para.ChildObjects.Count;
                         j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
                else if (i == endOwnerParaIndex)
                {
                    for (int j = 0; j < endIndex; j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
                else
                {
                    for (int j = 0;
                         j < para.ChildObjects.Count;
                         j++)
                    {
                        FormatText(para.ChildObjects[j] as TextRange);
                    }
                }
            }
        }

        // Установить текст гиперссылки в черный цвет без подчеркивания
        private static void FormatText(TextRange textRange)
        {
            if (textRange == null)
                return;

            textRange.CharacterFormat.TextColor = Color.Black;
            textRange.CharacterFormat.UnderlineStyle =
                UnderlineStyle.None;
        }
    }
}

Шаг 3: Запуск программы

Обновите пути к входной и выходной папкам, поместите файлы DOCX во входную папку и запустите приложение. Очищенные копии будут сохранены в выходной папке с исходными именами файлов.

Для большой партии сначала протестируйте программу на нескольких типичных документах.

Результат:

⚠️ Техническое примечание: Этот фрагмент кода C# нацелен на абзацы верхнего уровня. Если ваши документы содержат гиперссылки, вложенные в таблицы, текстовые поля или колонтитулы, логику обхода следует расширить для рекурсивного сканирования этих дочерних элементов.

Код также сбрасывает цвет текста гиперссылки на черный и удаляет подчеркивание. Если вам нужно только изменить цвет или удалить подчеркивание гиперссылок, не удаляя сами ссылки, вы можете изменить форматирование гиперссылок отдельно.

Бонус: Как запретить Word автоматически создавать гиперссылки

Если проблема в том, что Word постоянно превращает URL-адреса и адреса электронной почты в ссылки при вводе текста, вы можете отключить автоматическое создание гиперссылок, вместо того чтобы постоянно удалять их.

В Word для Windows

1. Нажмите Файл в левом верхнем углу, затем выберите Параметры в нижней части боковой панели.

2. Выберите категорию Правописание на левой панели.

3. Нажмите кнопку Параметры автозамены... в верхней части.

4. Перейдите на вкладку Автоформат при вводе.

5. Снимите флажок рядом с пунктом адреса Интернета и сетевые пути гиперссылками.

6. Нажмите ОК, чтобы применить.

В Word для Mac

1. Нажмите Word в верхней строке меню Apple и выберите Параметры.

2. Откройте инструмент Автозамена в разделе «Авторство».

3. Перейдите на вкладку Автоформат при вводе.

4. Снимите флажок адреса Интернета и сетевые пути гиперссылками.

Изменение этого параметра предотвращает форматирование будущих ссылок при вводе. Это не затронет и не очистит гиперссылки, которые уже сохранены в вашем текущем документе.

Что проверить после удаления гиперссылок

Удаление гиперссылок обычно проходит просто, но после этого стоит проверить несколько деталей, особенно форматирование, динамические поля и ссылки в отдельных областях документа.

• Проверьте цвет текста и подчеркивание: Если текст остается синим или подчеркнутым, установите цвет шрифта на Авто или подберите его под окружающий текст, а затем при необходимости удалите подчеркивание.

• Проверьте динамические поля: Если вы использовали сочетание клавиш Ctrl + Shift + F9, проверьте оглавление, перекрестные ссылки и цитаты. Убедитесь, что они случайно не превратились в обычный текст, который нельзя обновить.

• Проверьте колонтитулы: Ctrl + A не выделяет текст внутри колонтитулов. Дважды щелкните внутри этих областей вручную, чтобы очистить оставшиеся скрытые ссылки.

Часто задаваемые вопросы

В: Удаляет ли удаление гиперссылки отображаемый текст?

О: Нет. Команда Удалить гиперссылку удаляет ссылку, сохраняя отображаемый текст на месте.

В: Как удалить синее подчеркивание, не разрывая ссылку?

О: Выделите гиперссылку, перейдите на вкладку Главная, установите цвет шрифта на Авто или подберите его под окружающий текст, а затем нажмите кнопку Подчеркнутый (или нажмите Ctrl + U), чтобы отключить подчеркивание.

В: Как удалить гиперссылку с изображения в Word?

О: Нажмите правой кнопкой мыши на изображение с гиперссылкой и выберите Удалить гиперссылку. В автоматизированных рабочих процессах гиперссылками на изображениях также можно управлять программно.

В: Можно ли удалить гиперссылки из Word без установки Word?

О: Да. Вы можете открыть и отредактировать файл в браузере с помощью Word для интернета. Для нескольких файлов вы также можете использовать C# с библиотекой, такой как Spire.Doc, для автоматизации удаления.

Заключение

Выбор лучшего способа удаления гиперссылок зависит от контекста вашего редактирования. Для быстрого ручного редактирования идеально подходят встроенные команды Word и сочетания клавиш. Для автоматизированных рабочих процессов или больших коллекций файлов DOCX автоматизация скриптов на C# обеспечивает надежное и масштабируемое решение.

As tabelas do Word são úteis para organizar dados, mas podem se tornar inconvenientes quando você precisa editar seu conteúdo como texto comum. Se você não precisa mais da estrutura da tabela, pode converter uma tabela em texto usando a ferramenta integrada do Word ou automatizar o processo com Python. Este guia aborda etapas detalhadas para ambos os métodos; vamos conferi-los.

• Converter Tabela em Texto no Word com uma Ferramenta Integrada
• Converter Tabelas do Word em Texto com Python
  • Convertendo uma Tabela em Texto
  • Processamento em Lote de Todas as Tabelas
• Exportar Dados de Tabela para um Arquivo TXT Externo
• Perguntas Frequentes

Converter Tabela em Texto no Word com uma Ferramenta Integrada

O Microsoft Word oferece uma ferramenta integrada para converter tabelas em texto. Se você precisa converter apenas uma ou duas tabelas, a ferramenta integrada geralmente é a opção mais rápida. Ela remove a estrutura da tabela e converte o conteúdo das células em texto comum.

Como transformar uma tabela em texto no MS Word:

• Passo 1: Clique em qualquer lugar dentro da tabela para revelar a guia contextual Layout da Tabela na faixa de opções superior.
• Passo 2: Vá para a guia Layout da Tabela no menu superior e clique no botão Converter em Texto no grupo Dados.

• Passo 3: Selecione o delimitador de sua preferência (tabulações, vírgulas, marcas de parágrafo ou um caractere personalizado) para separar os valores das colunas.

• Passo 4: Clique em OK para transformar a tabela em parágrafos de texto comum instantaneamente.

Converter em Texto vs. Ocultar Bordas

Ocultar bordas da tabela apenas altera a aparência da tabela. As células, colunas e a estrutura da tabela permanecem no lugar, portanto, o conteúdo ainda fica restrito ao layout da tabela.

Converter a tabela em texto remove a estrutura da tabela e transforma o conteúdo das células em parágrafos comuns. Você pode então editar e formatar o conteúdo sem o layout da tabela.

Converter Tabelas do Word em Texto com Python

A ferramenta integrada do Word é conveniente para converter tabelas individuais, mas torna-se menos prática quando você precisa processar muitos documentos ou tabelas. Para desenvolvedores Python, o Free Spire.Doc for Python oferece uma maneira de automatizar a conversão de tabela para texto sem a necessidade de ter o Microsoft Word instalado.

Convertendo uma Tabela em Texto

O script lê o texto de cada célula, une as células na mesma linha com caracteres de tabulação, insere os parágrafos resultantes onde a tabela estava localizada e, em seguida, remove a tabela original.

from spire.doc import *
from spire.doc.documents import *

# Inicializar instância do Documento e carregar o arquivo alvo
doc = Document()
doc.LoadFromFile("input.docx")

# Obter a primeira seção e a tabela alvo
section = doc.Sections[0]
if section.Tables.Count > 0:
    table = section.Tables[0]

    # Extrair texto das células linha por linha
    text_lines = []
    for j in range(table.Rows.Count):
        row = table.Rows.get_Item(j)
        row_cells_text = []
        for k in range(row.Cells.Count):
            cell = row.Cells.get_Item(k)

            # Extrair texto dos parágrafos da célula
            cell_text_pieces = []
            for p in range(cell.Paragraphs.Count):
                para_obj = cell.Paragraphs.get_Item(p)
                if para_obj.Text:
                    cell_text_pieces.append(para_obj.Text.strip())

            row_cells_text.append(" ".join(cell_text_pieces))

        # Unir texto da célula usando separadores de Tabulação
        text_lines.append("\t".join(row_cells_text))

    # Localizar a tabela dentro de seu bloco pai
    owner_block = table.OwnerTextBody
    table_index = owner_block.ChildObjects.IndexOf(table)

    # Inserir novos parágrafos de texto na posição exata da tabela
    for line in reversed(text_lines):
        temp_para = section.AddParagraph()
        temp_para.Text = line
        section.Paragraphs.Remove(temp_para)
        owner_block.ChildObjects.Insert(table_index, temp_para)

    # Remover completamente a estrutura da tabela da estrutura do documento
    owner_block.ChildObjects.Remove(table)

# Salvar o documento atualizado
doc.SaveToFile("1st table to text.docx", FileFormat.Docx2016)
doc.Close()

Nota: Múltiplos parágrafos dentro da mesma célula são combinados em uma única linha separada por espaços.

Processamento em Lote de Todas as Tabelas

Para converter todas as tabelas em um documento em texto, reutilize a lógica de conversão do exemplo anterior e aplique-a a cada tabela em cada seção. Como cada tabela é removida após a conversão, as tabelas devem ser processadas em ordem inversa. Caso contrário, excluir uma tabela altera os índices das tabelas restantes, o que pode fazer com que tabelas sejam ignoradas ou resultar em erros de índice.

from spire.doc import *
from spire.doc.documents import *

# Criar um objeto Document e carregar um arquivo Word
doc = Document()
doc.LoadFromFile("input.docx")

# Iterar por cada seção no documento
for s_idx in range(doc.Sections.Count):
    section = doc.Sections[s_idx]

    # Iterar de trás para frente pelas tabelas para evitar problemas de deslocamento de índice
    table_count = section.Tables.Count
    for t_idx in range(table_count - 1, -1, -1):
        table = section.Tables.get_Item(t_idx)

        # Coletar texto de todas as linhas e células
        text_lines = []
        for j in range(table.Rows.Count):
            row = table.Rows.get_Item(j)
            row_cells_text = []
            for k in range(row.Cells.Count):
                cell = row.Cells.get_Item(k)
                cell_text_pieces = []
                for p in range(cell.Paragraphs.Count):
                    para_obj = cell.Paragraphs.get_Item(p)
                    if para_obj.Text:
                        cell_text_pieces.append(para_obj.Text.strip())
                row_cells_text.append(" ".join(cell_text_pieces))
            text_lines.append("\t".join(row_cells_text))

        # Substituir o nó da tabela por parágrafos simples no local
        owner_block = table.OwnerTextBody
        table_index = owner_block.ChildObjects.IndexOf(table)

        for line in reversed(text_lines):
            temp_para = section.AddParagraph()
            temp_para.Text = line
            section.Paragraphs.Remove(temp_para)
            owner_block.ChildObjects.Insert(table_index, temp_para)

        # Remover com segurança a tabela atual
        owner_block.ChildObjects.Remove(table)

# Salvar o arquivo final
doc.SaveToFile("all tables to text.docx", FileFormat.Docx2016)
doc.Close()

Dica: Exportar Dados de Tabela para um Arquivo TXT Externo

Em muitos fluxos de trabalho de pipeline de dados, o objetivo é obter informações em vez de modificar arquivos de layout originais. Se você precisa apenas de texto tabular para ingestão em banco de dados, registro ou arquivamento de texto simples, é ainda mais fácil. Você pode extrair rapidamente conteúdos brutos das células e gravá-los diretamente em um arquivo de texto externo com o Free Spire.Doc.

Exemplo de Código

from spire.doc import *
from spire.doc.common import *

# Criar uma instância de Documento
doc = Document()

# Carregar um documento Word
doc.LoadFromFile("input.docx")

# Obter a primeira tabela
table = doc.Sections[0].Tables[0]

# Extrair texto da tabela
tableData = ''
for j in range(table.Rows.Count):
    row = table.Rows.get_Item(j)

    for k in range(row.Cells.Count):
        cell = row.Cells.get_Item(k)

        for p in range(cell.Paragraphs.Count):
            tableData += cell.Paragraphs.get_Item(p).Text + ' '

        if k < row.Cells.Count - 1:
            tableData += '\t'

    tableData += '\n'

# Salvar o texto extraído em um arquivo TXT
with open("/table_text.txt", "w", encoding="utf-8") as f:
    f.write(tableData)

doc.Close()

Dica: Para dados tabulares estruturados, você também pode converter tabelas do Word para CSV para uso em planilhas, bancos de dados e outros fluxos de trabalho de processamento de dados.

Perguntas Frequentes

Q1: O que devo fazer se o texto convertido parecer desalinhado?

O uso de tabulações (\t) preserva melhor o espaçamento estrutural. Se o alinhamento das colunas ainda parecer irregular no Word, selecione os parágrafos convertidos e ajuste as Paradas de Tabulação na régua horizontal.

Q2: Como posso converter texto de volta para uma tabela no Word?

Para reverter o processo, destaque seu texto, vá para Inserir > Tabela e clique em Converter Texto em Tabela. Selecione o delimitador correspondente (por exemplo, tabulações ou vírgulas) para reconstruir sua tabela.

Q3: Qual é a tecla de atalho para converter uma tabela em texto no Word?

O Microsoft Word não oferece um atalho de teclado dedicado para Converter em Texto. Você pode acessar o comando através da Faixa de Opções ou personalizar um atalho através das configurações de teclado do Word.

Resumo

Este artigo apresentou duas maneiras de converter tabelas em documentos Word para texto. A ferramenta integrada do Word funciona bem para tabelas individuais ou um pequeno número de documentos, enquanto o Free Spire.Doc for Python é mais adequado para o processamento automatizado de várias tabelas. Você também pode extrair conteúdos de tabelas para um arquivo TXT para armazenamento em texto simples ou processamento posterior.

Leia Também:

• Como Dividir uma Tabela no Word? (Atalhos + VBA + C#)
• Python: Adicionar ou Excluir Linhas e Colunas de Tabela no Word
• Python: Definir Alinhamento para Tabela e Texto de Tabela no Word
• Python: Remover Tabelas no Word

Word 표는 데이터를 정리하는 데 유용하지만, 내용을 일반 텍스트로 편집해야 할 때는 불편할 수 있습니다. 더 이상 표 구조가 필요하지 않은 경우 Word의 내장 도구를 사용하여 표를 텍스트로 변환하거나 Python으로 프로세스를 자동화할 수 있습니다. 이 가이드에서는 두 가지 방법에 대한 자세한 단계를 설명합니다. 함께 살펴보겠습니다.

• 내장 도구를 사용하여 Word에서 표를 텍스트로 변환하기
• Python으로 Word 표를 텍스트로 변환하기
  • 표를 텍스트로 변환하기
  • 모든 표 일괄 처리하기
• 표 데이터를 외부 TXT 파일로 내보내기
• 자주 묻는 질문(FAQ)

내장 도구를 사용하여 Word에서 표를 텍스트로 변환하기

Microsoft Word는 표를 텍스트로 변환하는 내장 도구를 제공합니다. 한두 개의 표만 변환해야 하는 경우 내장 도구가 가장 빠른 옵션입니다. 표 구조를 제거하고 셀 내용을 일반 텍스트로 변환합니다.

MS Word에서 표를 텍스트로 변경하는 방법:

• 1단계: 표 내부의 아무 곳이나 클릭하여 상단 리본 메뉴에 표 레이아웃 탭이 나타나게 합니다.
• 2단계: 상단 메뉴의 표 레이아웃 탭으로 이동하여 데이터 그룹에서 텍스트로 변환 버튼을 클릭합니다.

• 3단계: 열 값을 구분할 원하는 구분 기호(탭, 쉼표, 단락 기호 또는 사용자 지정 문자)를 선택합니다.

• 4단계: 확인을 클릭하면 표가 즉시 일반 텍스트 단락으로 변환됩니다.

텍스트로 변환 vs. 테두리 숨기기

표 테두리를 숨기면 표의 외관만 변경됩니다. 셀, 열 및 표 구조는 그대로 유지되므로 콘텐츠는 여전히 표 레이아웃에 의해 제한됩니다.

표를 텍스트로 변환하면 표 구조가 제거되고 셀 내용이 일반 단락으로 바뀝니다. 그런 다음 표 레이아웃 없이 콘텐츠를 편집하고 서식을 지정할 수 있습니다.

Python으로 Word 표를 텍스트로 변환하기

Word의 내장 도구는 개별 표를 변환하는 데 편리하지만, 많은 문서나 표를 처리해야 할 때는 실용성이 떨어집니다. Python 개발자의 경우 Free Spire.Doc for Python을 사용하면 Microsoft Word를 설치하지 않고도 표에서 텍스트로의 변환을 자동화할 수 있습니다.

표를 텍스트로 변환하기

스크립트는 각 셀의 텍스트를 읽고, 동일한 행의 셀을 탭 문자로 연결하고, 결과 단락을 표가 있던 위치에 삽입한 다음 원래 표를 제거합니다.

from spire.doc import *
from spire.doc.documents import *

# Initialize Document instance and load the target file
doc = Document()
doc.LoadFromFile("input.docx")

# Get the first section and target table
section = doc.Sections[0]
if section.Tables.Count > 0:
    table = section.Tables[0]

    # Extract text from cells line by line
    text_lines = []
    for j in range(table.Rows.Count):
        row = table.Rows.get_Item(j)
        row_cells_text = []
        for k in range(row.Cells.Count):
            cell = row.Cells.get_Item(k)

            # Extract text from cell paragraphs
            cell_text_pieces = []
            for p in range(cell.Paragraphs.Count):
                para_obj = cell.Paragraphs.get_Item(p)
                if para_obj.Text:
                    cell_text_pieces.append(para_obj.Text.strip())

            row_cells_text.append(" ".join(cell_text_pieces))

        # Join cell text using Tab separators
        text_lines.append("\t".join(row_cells_text))

    # Locate the table inside its parent block
    owner_block = table.OwnerTextBody
    table_index = owner_block.ChildObjects.IndexOf(table)

    # Insert new text paragraphs at the exact table position
    for line in reversed(text_lines):
        temp_para = section.AddParagraph()
        temp_para.Text = line
        section.Paragraphs.Remove(temp_para)
        owner_block.ChildObjects.Insert(table_index, temp_para)

    # Completely remove the table structure from the document structure
    owner_block.ChildObjects.Remove(table)

# Save the updated document
doc.SaveToFile("1st table to text.docx", FileFormat.Docx2016)
doc.Close()

참고: 동일한 셀 내의 여러 단락은 공백으로 구분된 단일 행으로 결합됩니다.

모든 표 일괄 처리하기

문서의 모든 표를 텍스트로 변환하려면 이전 예제의 변환 로직을 재사용하여 모든 섹션의 모든 표에 적용합니다. 변환 후 각 표가 제거되므로 표는 역순으로 처리해야 합니다. 그렇지 않으면 표를 삭제할 때 남은 표의 인덱스가 이동하여 표가 누락되거나 인덱스 오류가 발생할 수 있습니다.

from spire.doc import *
from spire.doc.documents import *

# Create a Document object and load a Word file
doc = Document()
doc.LoadFromFile("input.docx")

# Iterate through every section in the document
for s_idx in range(doc.Sections.Count):
    section = doc.Sections[s_idx]

    # Iterate backwards through tables to avoid index shifting issues
    table_count = section.Tables.Count
    for t_idx in range(table_count - 1, -1, -1):
        table = section.Tables.get_Item(t_idx)

        # Collect text from all rows and cells
        text_lines = []
        for j in range(table.Rows.Count):
            row = table.Rows.get_Item(j)
            row_cells_text = []
            for k in range(row.Cells.Count):
                cell = row.Cells.get_Item(k)
                cell_text_pieces = []
                for p in range(cell.Paragraphs.Count):
                    para_obj = cell.Paragraphs.get_Item(p)
                    if para_obj.Text:
                        cell_text_pieces.append(para_obj.Text.strip())
                row_cells_text.append(" ".join(cell_text_pieces))
            text_lines.append("\t".join(row_cells_text))

        # Replace the table node with plain paragraphs in-place
        owner_block = table.OwnerTextBody
        table_index = owner_block.ChildObjects.IndexOf(table)

        for line in reversed(text_lines):
            temp_para = section.AddParagraph()
            temp_para.Text = line
            section.Paragraphs.Remove(temp_para)
            owner_block.ChildObjects.Insert(table_index, temp_para)

        # Safely remove the current table
        owner_block.ChildObjects.Remove(table)

# Save the final file
doc.SaveToFile("all tables to text.docx", FileFormat.Docx2016)
doc.Close()

팁: 표 데이터를 외부 TXT 파일로 내보내기

많은 데이터 파이프라인 워크플로에서 목표는 원본 레이아웃 파일을 수정하는 것보다 정보를 얻는 것입니다. 데이터베이스 수집, 로깅 또는 일반 텍스트 보관을 위한 표 형식의 텍스트만 필요한 경우에는 훨씬 더 간단합니다. Free Spire.Doc을 사용하면 원본 셀 내용을 신속하게 추출하여 외부 텍스트 파일에 직접 입력할 수 있습니다.

코드 예제

from spire.doc import *
from spire.doc.common import *

# Create a Document instance
doc = Document()

# Load a Word document
doc.LoadFromFile("input.docx")

# Get the first table
table = doc.Sections[0].Tables[0]

# Extract table text
tableData = ''
for j in range(table.Rows.Count):
    row = table.Rows.get_Item(j)

    for k in range(row.Cells.Count):
        cell = row.Cells.get_Item(k)

        for p in range(cell.Paragraphs.Count):
            tableData += cell.Paragraphs.get_Item(p).Text + ' '

        if k < row.Cells.Count - 1:
            tableData += '\t'

    tableData += '\n'

# Save the extracted text to a TXT file
with open("/table_text.txt", "w", encoding="utf-8") as f:
    f.write(tableData)

doc.Close()

팁: 구조화된 표 형식 데이터의 경우, 스프레드시트, 데이터베이스 및 기타 데이터 처리 워크플로에서 사용할 수 있도록 Word 표를 CSV로 변환할 수도 있습니다.

자주 묻는 질문

Q1: 변환된 텍스트가 정렬되지 않은 것처럼 보이면 어떻게 해야 하나요?

탭(\t)을 사용하면 구조적 간격이 가장 잘 유지됩니다. Word에서 열 정렬이 여전히 고르지 않게 보이면 변환된 단락을 선택하고 가로 자에서 탭 정지 위치를 조정하세요.

Q2: Word에서 텍스트를 다시 표로 변환하려면 어떻게 해야 하나요?

프로세스를 되돌리려면 텍스트를 강조 표시하고 삽입 > 표로 이동한 다음 텍스트를 표로 변환을 클릭합니다. 일치하는 구분 기호(예: 탭 또는 쉼표)를 선택하여 표를 다시 만듭니다.

Q3: Word에서 표를 텍스트로 변환하는 단축키는 무엇인가요?

Microsoft Word는 텍스트로 변환에 대한 전용 키보드 단축키를 제공하지 않습니다. 리본 메뉴를 통해 명령에 액세스하거나 Word의 키보드 설정을 통해 단축키를 사용자 지정할 수 있습니다.

요약

이 문서에서는 Word 문서의 표를 텍스트로 변환하는 두 가지 방법을 소개했습니다. Word의 내장 도구는 개별 표나 적은 수의 문서에 적합하며, Free Spire.Doc for Python은 여러 표의 자동 처리 작업에 더 적합합니다. 표 내용을 TXT 파일로 추출하여 일반 텍스트 저장 또는 추가 처리에 활용할 수도 있습니다.

함께 읽어보기:

• Word에서 표를 나누는 방법 (단축키 + VBA + C#)
• Python: Word에서 표 행 및 열 추가 또는 삭제
• Python: Word에서 표 및 표 텍스트의 정렬 설정
• Python: Word에서 표 제거

Le tabelle di Word sono utili per organizzare i dati, ma possono diventare scomode quando è necessario modificarne il contenuto come testo normale. Se non hai più bisogno della struttura della tabella, puoi convertire una tabella in testo utilizzando lo strumento integrato di Word o automatizzare il processo con Python. Questa guida illustra i passaggi dettagliati per entrambi i metodi, diamo un'occhiata.

• Convertire una tabella in testo in Word con uno strumento integrato
• Convertire tabelle Word in testo con Python
  • Convertire una tabella in testo
  • Elaborazione in batch di tutte le tabelle
• Esportare i dati della tabella in un file TXT esterno
• Domande frequenti (FAQ)

Convertire una tabella in testo in Word con uno strumento integrato

Microsoft Word fornisce uno strumento integrato per convertire le tabelle in testo. Se devi convertire solo una o due tabelle, lo strumento integrato è solitamente l'opzione più rapida. Rimuove la struttura della tabella e converte il contenuto delle celle in testo normale.

Come trasformare una tabella in testo in MS Word:

• Passaggio 1: Fai clic in un punto qualsiasi all'interno della tabella per visualizzare la scheda contestuale Layout tabella sulla barra multifunzione in alto.
• Passaggio 2: Vai alla scheda Layout tabella nel menu in alto e fai clic sul pulsante Converti in testo nel gruppo Dati.

• Passaggio 3: Seleziona il delimitatore preferito (tabulazioni, virgole, segni di paragrafo o un carattere personalizzato) per separare i valori delle colonne.

• Passaggio 4: Fai clic su OK per trasformare istantaneamente la tabella in normali paragrafi di testo.

Conversione in testo vs. Nascondere i bordi

Nascondere i bordi della tabella cambia solo l'aspetto della tabella. Le celle, le colonne e la struttura della tabella rimangono al loro posto, quindi il contenuto è ancora vincolato dal layout della tabella.

Convertire la tabella in testo rimuove la struttura della tabella e trasforma il contenuto delle celle in normali paragrafi. È quindi possibile modificare e formattare il contenuto senza il layout della tabella.

Convertire tabelle Word in testo con Python

Lo strumento integrato di Word è comodo per convertire singole tabelle, ma diventa meno pratico quando è necessario elaborare molti documenti o tabelle. Per gli sviluppatori Python, Free Spire.Doc for Python offre un modo per automatizzare la conversione da tabella a testo senza richiedere l'installazione di Microsoft Word.

Convertire una tabella in testo

Lo script legge il testo da ogni cella, unisce le celle nella stessa riga con caratteri di tabulazione, inserisce i paragrafi risultanti dove si trovava la tabella e quindi rimuove la tabella originale.

from spire.doc import *
from spire.doc.documents import *

# Inizializza l'istanza del documento e carica il file di destinazione
doc = Document()
doc.LoadFromFile("input.docx")

# Ottieni la prima sezione e la tabella di destinazione
section = doc.Sections[0]
if section.Tables.Count > 0:
    table = section.Tables[0]

    # Estrai il testo dalle celle riga per riga
    text_lines = []
    for j in range(table.Rows.Count):
        row = table.Rows.get_Item(j)
        row_cells_text = []
        for k in range(row.Cells.Count):
            cell = row.Cells.get_Item(k)

            # Estrai il testo dai paragrafi della cella
            cell_text_pieces = []
            for p in range(cell.Paragraphs.Count):
                para_obj = cell.Paragraphs.get_Item(p)
                if para_obj.Text:
                    cell_text_pieces.append(para_obj.Text.strip())

            row_cells_text.append(" ".join(cell_text_pieces))

        # Unisci il testo delle celle usando i separatori di tabulazione
        text_lines.append("\t".join(row_cells_text))

    # Individua la tabella all'interno del suo blocco padre
    owner_block = table.OwnerTextBody
    table_index = owner_block.ChildObjects.IndexOf(table)

    # Inserisci nuovi paragrafi di testo nell'esatta posizione della tabella
    for line in reversed(text_lines):
        temp_para = section.AddParagraph()
        temp_para.Text = line
        section.Paragraphs.Remove(temp_para)
        owner_block.ChildObjects.Insert(table_index, temp_para)

    # Rimuovi completamente la struttura della tabella dalla struttura del documento
    owner_block.ChildObjects.Remove(table)

# Salva il documento aggiornato
doc.SaveToFile("1st table to text.docx", FileFormat.Docx2016)
doc.Close()

Nota: Più paragrafi all'interno della stessa cella vengono combinati in un'unica riga separata da spazi.

Elaborazione in batch di tutte le tabelle

Per convertire tutte le tabelle in un documento in testo, riutilizza la logica di conversione dell'esempio precedente e applicala a ogni tabella in ogni sezione. Poiché ogni tabella viene rimossa dopo la conversione, le tabelle dovrebbero essere elaborate in ordine inverso. In caso contrario, l'eliminazione di una tabella sposta gli indici delle tabelle rimanenti, il che potrebbe causare il salto di tabelle o errori di indice.

from spire.doc import *
from spire.doc.documents import *

# Crea un oggetto Document e carica un file Word
doc = Document()
doc.LoadFromFile("input.docx")

# Itera attraverso ogni sezione nel documento
for s_idx in range(doc.Sections.Count):
    section = doc.Sections[s_idx]

    # Itera all'indietro attraverso le tabelle per evitare problemi di spostamento dell'indice
    table_count = section.Tables.Count
    for t_idx in range(table_count - 1, -1, -1):
        table = section.Tables.get_Item(t_idx)

        # Raccogli il testo da tutte le righe e celle
        text_lines = []
        for j in range(table.Rows.Count):
            row = table.Rows.get_Item(j)
            row_cells_text = []
            for k in range(row.Cells.Count):
                cell = row.Cells.get_Item(k)
                cell_text_pieces = []
                for p in range(cell.Paragraphs.Count):
                    para_obj = cell.Paragraphs.get_Item(p)
                    if para_obj.Text:
                        cell_text_pieces.append(para_obj.Text.strip())
                row_cells_text.append(" ".join(cell_text_pieces))
            text_lines.append("\t".join(row_cells_text))

        # Sostituisci il nodo della tabella con paragrafi semplici sul posto
        owner_block = table.OwnerTextBody
        table_index = owner_block.ChildObjects.IndexOf(table)

        for line in reversed(text_lines):
            temp_para = section.AddParagraph()
            temp_para.Text = line
            section.Paragraphs.Remove(temp_para)
            owner_block.ChildObjects.Insert(table_index, temp_para)

        # Rimuovi in sicurezza la tabella corrente
        owner_block.ChildObjects.Remove(table)

# Salva il file finale
doc.SaveToFile("all tables to text.docx", FileFormat.Docx2016)
doc.Close()

Suggerimento: Esportare i dati della tabella in un file TXT esterno

In molti flussi di lavoro di pipeline di dati, l'obiettivo è ottenere informazioni piuttosto che modificare i file di layout originali. Se hai bisogno solo di testo tabulare per l'inserimento in database, la registrazione o l'archiviazione in testo semplice, è ancora più semplice. Puoi estrarre rapidamente il contenuto grezzo delle celle e scriverlo direttamente in un file di testo esterno con Free Spire.Doc.

Esempio di codice

from spire.doc import *
from spire.doc.common import *

# Crea un'istanza Document
doc = Document()

# Carica un documento Word
doc.LoadFromFile("input.docx")

# Ottieni la prima tabella
table = doc.Sections[0].Tables[0]

# Estrai il testo della tabella
tableData = ''
for j in range(table.Rows.Count):
    row = table.Rows.get_Item(j)

    for k in range(row.Cells.Count):
        cell = row.Cells.get_Item(k)

        for p in range(cell.Paragraphs.Count):
            tableData += cell.Paragraphs.get_Item(p).Text + ' '

        if k < row.Cells.Count - 1:
            tableData += '\t'

    tableData += '\n'

# Salva il testo estratto in un file TXT
with open("/table_text.txt", "w", encoding="utf-8") as f:
    f.write(tableData)

doc.Close()

Suggerimento: Per dati tabulari strutturati, puoi anche convertire le tabelle Word in CSV per l'uso in fogli di calcolo, database e altri flussi di lavoro di elaborazione dati.

Domande frequenti (FAQ)

D1: Cosa devo fare se il testo convertito appare disallineato?

L'uso delle tabulazioni (\t) preserva al meglio la spaziatura strutturale. Se l'allineamento delle colonne appare ancora irregolare in Word, seleziona i paragrafi convertiti e regola le Tabulazioni sul righello orizzontale.

D2: Come posso riconvertire il testo in una tabella in Word?

Per invertire il processo, evidenzia il testo, vai su Inserisci > Tabella e fai clic su Converti testo in tabella. Seleziona il delimitatore corrispondente (ad esempio, tabulazioni o virgole) per ricostruire la tabella.

D3: Qual è il tasto di scelta rapida per convertire una tabella in testo in Word?

Microsoft Word non fornisce una scorciatoia da tastiera dedicata per Converti in testo. Puoi accedere al comando tramite la barra multifunzione o personalizzare una scorciatoia tramite le impostazioni della tastiera di Word.

Riepilogo

Questo articolo ha introdotto due modi per convertire le tabelle nei documenti Word in testo. Lo strumento integrato di Word funziona bene per singole tabelle o un numero limitato di documenti, mentre Free Spire.Doc for Python è più adatto all'elaborazione automatizzata di più tabelle. Puoi anche estrarre il contenuto della tabella in un file TXT per l'archiviazione in testo semplice o per un'ulteriore elaborazione.

Leggi anche:

• Come dividere una tabella in Word? (Scorciatoie + VBA + C#)
• Python: Aggiungere o eliminare righe e colonne di tabella in Word
• Python: Impostare l'allineamento per la tabella e il testo della tabella in Word
• Python: Rimuovere tabelle in Word

Les tableaux Word sont utiles pour organiser les données, mais ils peuvent devenir gênants lorsque vous devez modifier leur contenu sous forme de texte brut. Si vous n'avez plus besoin de la structure du tableau, vous pouvez convertir un tableau en texte en utilisant l'outil intégré de Word ou automatiser le processus avec Python. Ce guide détaille les deux méthodes, découvrons-les.

• Convertir un tableau en texte dans Word avec un outil intégré
• Convertir des tableaux Word en texte avec Python
  • Convertir un tableau en texte
  • Traitement par lots de tous les tableaux
• Exporter les données d'un tableau vers un fichier TXT externe
• FAQ

Convertir un tableau en texte dans Word avec un outil intégré

Microsoft Word fournit un outil intégré pour convertir les tableaux en texte. Si vous n'avez besoin de convertir qu'un ou deux tableaux, l'outil intégré est généralement l'option la plus rapide. Il supprime la structure du tableau et convertit le contenu des cellules en texte brut.

Comment transformer un tableau en texte dans MS Word :

• Étape 1 : Cliquez n'importe où à l'intérieur du tableau pour faire apparaître l'onglet contextuel Disposition (ou Mise en page) dans le ruban supérieur.
• Étape 2 : Allez dans l'onglet Disposition du menu supérieur et cliquez sur le bouton Convertir en texte dans le groupe Données.

• Étape 3 : Sélectionnez le délimiteur de votre choix (tabulations, virgules, marques de paragraphe ou un caractère personnalisé) pour séparer les valeurs des colonnes.

• Étape 4 : Cliquez sur OK pour transformer instantanément le tableau en paragraphes de texte brut.

Conversion en texte vs Masquage des bordures

Masquer les bordures d'un tableau modifie uniquement l'apparence du tableau. Les cellules, les colonnes et la structure du tableau restent en place, de sorte que le contenu est toujours contraint par la mise en page du tableau.

La conversion du tableau en texte supprime la structure du tableau et transforme le contenu des cellules en paragraphes ordinaires. Vous pouvez ensuite modifier et mettre en forme le contenu sans la contrainte de la mise en page du tableau.

Convertir des tableaux Word en texte avec Python

L'outil intégré de Word est pratique pour convertir des tableaux individuels, mais il devient moins efficace lorsque vous devez traiter de nombreux documents ou tableaux. Pour les développeurs Python, Free Spire.Doc for Python offre un moyen d'automatiser la conversion de tableau en texte sans avoir besoin d'installer Microsoft Word.

Convertir un tableau en texte

Le script lit le texte de chaque cellule, joint les cellules d'une même ligne avec des tabulations, insère les paragraphes résultants là où se trouvait le tableau, puis supprime le tableau d'origine.

from spire.doc import *
from spire.doc.documents import *

# Initialiser l'instance Document et charger le fichier cible
doc = Document()
doc.LoadFromFile("input.docx")

# Obtenir la première section et le tableau cible
section = doc.Sections[0]
if section.Tables.Count > 0:
    table = section.Tables[0]

    # Extraire le texte des cellules ligne par ligne
    text_lines = []
    for j in range(table.Rows.Count):
        row = table.Rows.get_Item(j)
        row_cells_text = []
        for k in range(row.Cells.Count):
            cell = row.Cells.get_Item(k)

            # Extraire le texte des paragraphes de la cellule
            cell_text_pieces = []
            for p in range(cell.Paragraphs.Count):
                para_obj = cell.Paragraphs.get_Item(p)
                if para_obj.Text:
                    cell_text_pieces.append(para_obj.Text.strip())

            row_cells_text.append(" ".join(cell_text_pieces))

        # Joindre le texte des cellules en utilisant des tabulations
        text_lines.append("\t".join(row_cells_text))

    # Localiser le tableau dans son bloc parent
    owner_block = table.OwnerTextBody
    table_index = owner_block.ChildObjects.IndexOf(table)

    # Insérer de nouveaux paragraphes de texte à la position exacte du tableau
    for line in reversed(text_lines):
        temp_para = section.AddParagraph()
        temp_para.Text = line
        section.Paragraphs.Remove(temp_para)
        owner_block.ChildObjects.Insert(table_index, temp_para)

    # Supprimer complètement la structure du tableau de la structure du document
    owner_block.ChildObjects.Remove(table)

# Enregistrer le document mis à jour
doc.SaveToFile("1st table to text.docx", FileFormat.Docx2016)
doc.Close()

Remarque : Les paragraphes multiples au sein d'une même cellule sont combinés en une seule ligne séparée par des espaces.

Traitement par lots de tous les tableaux

Pour convertir tous les tableaux d'un document en texte, réutilisez la logique de conversion de l'exemple précédent et appliquez-la à chaque tableau de chaque section. Comme chaque tableau est supprimé après la conversion, les tableaux doivent être traités dans l'ordre inverse. Sinon, la suppression d'un tableau décale les index des tableaux restants, ce qui peut entraîner l'omission de tableaux ou des erreurs d'index.

from spire.doc import *
from spire.doc.documents import *

# Créer un objet Document et charger un fichier Word
doc = Document()
doc.LoadFromFile("input.docx")

# Parcourir chaque section du document
for s_idx in range(doc.Sections.Count):
    section = doc.Sections[s_idx]

    # Parcourir les tableaux à l'envers pour éviter les problèmes de décalage d'index
    table_count = section.Tables.Count
    for t_idx in range(table_count - 1, -1, -1):
        table = section.Tables.get_Item(t_idx)

        # Collecter le texte de toutes les lignes et cellules
        text_lines = []
        for j in range(table.Rows.Count):
            row = table.Rows.get_Item(j)
            row_cells_text = []
            for k in range(row.Cells.Count):
                cell = row.Cells.get_Item(k)
                cell_text_pieces = []
                for p in range(cell.Paragraphs.Count):
                    para_obj = cell.Paragraphs.get_Item(p)
                    if para_obj.Text:
                        cell_text_pieces.append(para_obj.Text.strip())
                row_cells_text.append(" ".join(cell_text_pieces))
            text_lines.append("\t".join(row_cells_text))

        # Remplacer le nœud du tableau par des paragraphes simples sur place
        owner_block = table.OwnerTextBody
        table_index = owner_block.ChildObjects.IndexOf(table)

        for line in reversed(text_lines):
            temp_para = section.AddParagraph()
            temp_para.Text = line
            section.Paragraphs.Remove(temp_para)
            owner_block.ChildObjects.Insert(table_index, temp_para)

        # Supprimer le tableau actuel en toute sécurité
        owner_block.ChildObjects.Remove(table)

# Enregistrer le fichier final
doc.SaveToFile("all tables to text.docx", FileFormat.Docx2016)
doc.Close()

Astuce : Exporter les données d'un tableau vers un fichier TXT externe

Dans de nombreux flux de travail de données, l'objectif est d'obtenir des informations plutôt que de modifier les fichiers de mise en page d'origine. Si vous n'avez besoin que de texte tabulaire pour l'ingestion dans une base de données, la journalisation ou l'archivage en texte brut, c'est encore plus simple. Vous pouvez rapidement extraire le contenu brut des cellules et l'écrire directement dans un fichier texte externe avec Free Spire.Doc.

Exemple de code

from spire.doc import *
from spire.doc.common import *

# Créer une instance Document
doc = Document()

# Charger un document Word
doc.LoadFromFile("input.docx")

# Obtenir le premier tableau
table = doc.Sections[0].Tables[0]

# Extraire le texte du tableau
tableData = ''
for j in range(table.Rows.Count):
    row = table.Rows.get_Item(j)

    for k in range(row.Cells.Count):
        cell = row.Cells.get_Item(k)

        for p in range(cell.Paragraphs.Count):
            tableData += cell.Paragraphs.get_Item(p).Text + ' '

        if k < row.Cells.Count - 1:
            tableData += '\t'

    tableData += '\n'

# Enregistrer le texte extrait dans un fichier TXT
with open("/table_text.txt", "w", encoding="utf-8") as f:
    f.write(tableData)

doc.Close()

Astuce : Pour des données tabulaires structurées, vous pouvez également convertir les tableaux Word en CSV pour les utiliser dans des feuilles de calcul, des bases de données et d'autres flux de traitement de données.

Foire aux questions

Q1 : Que faire si le texte converti semble mal aligné ?

L'utilisation de tabulations (\t) préserve au mieux l'espacement structurel. Si l'alignement des colonnes semble toujours irrégulier dans Word, sélectionnez les paragraphes convertis et ajustez les tabulations sur la règle horizontale.

Q2 : Comment convertir du texte en tableau dans Word ?

Pour inverser le processus, mettez votre texte en surbrillance, allez dans Insertion > Tableau, et cliquez sur Convertir le texte en tableau. Sélectionnez le délimiteur correspondant (par exemple, tabulations ou virgules) pour reconstruire votre tableau.

Q3 : Quel est le raccourci clavier pour convertir un tableau en texte dans Word ?

Microsoft Word ne fournit pas de raccourci clavier dédié pour Convertir en texte. Vous pouvez accéder à la commande via le ruban ou personnaliser un raccourci via les paramètres clavier de Word.

Résumé

Cet article a présenté deux façons de convertir des tableaux dans des documents Word en texte. L'outil intégré de Word fonctionne bien pour les tableaux individuels ou un petit nombre de documents, tandis que Free Spire.Doc for Python est mieux adapté au traitement automatisé de plusieurs tableaux. Vous pouvez également extraire le contenu des tableaux vers un fichier TXT pour un stockage en texte brut ou un traitement ultérieur.

À lire également :

• Comment diviser un tableau dans Word ? (Raccourcis + VBA + C#)
• Python : Ajouter ou supprimer des lignes et des colonnes de tableau dans Word
• Python : Définir l'alignement du tableau et du texte du tableau dans Word
• Python : Supprimer des tableaux dans Word

Las tablas de Word son útiles para organizar datos, pero pueden resultar incómodas cuando necesitas editar su contenido como texto normal. Si ya no necesitas la estructura de tabla, puedes convertir una tabla a texto usando la herramienta integrada de Word o automatizar el proceso con Python. Esta guía cubre los pasos detallados para ambos métodos, vamos a verlos.

• Convertir tabla a texto en Word con una herramienta integrada
• Convertir tablas de Word a texto con Python
  • Convertir una tabla a texto
  • Procesamiento por lotes de todas las tablas
• Exportar datos de tabla a un archivo TXT externo
• Preguntas frecuentes

Convertir tabla a texto en Word con una herramienta integrada

Microsoft Word proporciona una herramienta integrada para convertir tablas a texto. Si solo necesitas convertir una o dos tablas, la herramienta integrada suele ser la opción más rápida. Elimina la estructura de la tabla y convierte el contenido de las celdas en texto normal.

Cómo cambiar una tabla a texto en MS Word:

• Paso 1: Haz clic en cualquier lugar dentro de la tabla para mostrar la pestaña contextual Disposición de tabla en la cinta superior.
• Paso 2: Ve a la pestaña Disposición de tabla en el menú superior y haz clic en el botón Convertir a texto en el grupo Datos.

• Paso 3: Selecciona tu delimitador preferido (tabulaciones, comas, marcas de párrafo o un carácter personalizado) para separar los valores de las columnas.

• Paso 4: Haz clic en Aceptar para transformar la tabla en párrafos de texto normal al instante.

Convertir a texto frente a ocultar bordes

Ocultar los bordes de la tabla solo cambia el aspecto de la tabla. Las celdas, columnas y la estructura de la tabla permanecen en su lugar, por lo que el contenido sigue estando restringido por el diseño de la tabla.

Convertir la tabla a texto elimina la estructura de la tabla y convierte el contenido de las celdas en párrafos normales. Luego puedes editar y dar formato al contenido sin el diseño de la tabla.

Convertir tablas de Word a texto con Python

La herramienta integrada de Word es conveniente para convertir tablas individuales, pero resulta menos práctica cuando necesitas procesar muchos documentos o tablas. Para los desarrolladores de Python, Free Spire.Doc for Python proporciona una forma de automatizar la conversión de tabla a texto sin necesidad de tener instalado Microsoft Word.

Convertir una tabla a texto

El script lee el texto de cada celda, une las celdas de la misma fila con caracteres de tabulación, inserta los párrafos resultantes donde estaba ubicada la tabla y luego elimina la tabla original.

from spire.doc import *
from spire.doc.documents import *

# Inicializar la instancia del documento y cargar el archivo de destino
doc = Document()
doc.LoadFromFile("input.docx")

# Obtener la primera sección y la tabla de destino
section = doc.Sections[0]
if section.Tables.Count > 0:
    table = section.Tables[0]

    # Extraer texto de las celdas línea por línea
    text_lines = []
    for j in range(table.Rows.Count):
        row = table.Rows.get_Item(j)
        row_cells_text = []
        for k in range(row.Cells.Count):
            cell = row.Cells.get_Item(k)

            # Extraer texto de los párrafos de la celda
            cell_text_pieces = []
            for p in range(cell.Paragraphs.Count):
                para_obj = cell.Paragraphs.get_Item(p)
                if para_obj.Text:
                    cell_text_pieces.append(para_obj.Text.strip())

            row_cells_text.append(" ".join(cell_text_pieces))

        # Unir el texto de la celda usando separadores de tabulación
        text_lines.append("\t".join(row_cells_text))

    # Localizar la tabla dentro de su bloque principal
    owner_block = table.OwnerTextBody
    table_index = owner_block.ChildObjects.IndexOf(table)

    # Insertar nuevos párrafos de texto en la posición exacta de la tabla
    for line in reversed(text_lines):
        temp_para = section.AddParagraph()
        temp_para.Text = line
        section.Paragraphs.Remove(temp_para)
        owner_block.ChildObjects.Insert(table_index, temp_para)

    # Eliminar completamente la estructura de la tabla de la estructura del documento
    owner_block.ChildObjects.Remove(table)

# Guardar el documento actualizado
doc.SaveToFile("1st table to text.docx", FileFormat.Docx2016)
doc.Close()

Nota: Los párrafos múltiples dentro de la misma celda se combinan en una sola línea separada por espacios.

Procesamiento por lotes de todas las tablas

Para convertir todas las tablas de un documento en texto, reutiliza la lógica de conversión del ejemplo anterior y aplícala a cada tabla en cada sección. Dado que cada tabla se elimina después de la conversión, las tablas deben procesarse en orden inverso. De lo contrario, eliminar una tabla desplaza los índices de las tablas restantes, lo que puede causar que se omitan tablas o provocar errores de índice.

from spire.doc import *
from spire.doc.documents import *

# Crear un objeto Document y cargar un archivo de Word
doc = Document()
doc.LoadFromFile("input.docx")

# Iterar a través de cada sección en el documento
for s_idx in range(doc.Sections.Count):
    section = doc.Sections[s_idx]

    # Iterar hacia atrás a través de las tablas para evitar problemas de desplazamiento de índice
    table_count = section.Tables.Count
    for t_idx in range(table_count - 1, -1, -1):
        table = section.Tables.get_Item(t_idx)

        # Recopilar texto de todas las filas y celdas
        text_lines = []
        for j in range(table.Rows.Count):
            row = table.Rows.get_Item(j)
            row_cells_text = []
            for k in range(row.Cells.Count):
                cell = row.Cells.get_Item(k)
                cell_text_pieces = []
                for p in range(cell.Paragraphs.Count):
                    para_obj = cell.Paragraphs.get_Item(p)
                    if para_obj.Text:
                        cell_text_pieces.append(para_obj.Text.strip())
                row_cells_text.append(" ".join(cell_text_pieces))
            text_lines.append("\t".join(row_cells_text))

        # Reemplazar el nodo de la tabla con párrafos simples en el lugar
        owner_block = table.OwnerTextBody
        table_index = owner_block.ChildObjects.IndexOf(table)

        for line in reversed(text_lines):
            temp_para = section.AddParagraph()
            temp_para.Text = line
            section.Paragraphs.Remove(temp_para)
            owner_block.ChildObjects.Insert(table_index, temp_para)

        # Eliminar de forma segura la tabla actual
        owner_block.ChildObjects.Remove(table)

# Guardar el archivo final
doc.SaveToFile("all tables to text.docx", FileFormat.Docx2016)
doc.Close()

Consejo: Exportar datos de tabla a un archivo TXT externo

En muchos flujos de trabajo de canalización de datos, el objetivo es obtener información en lugar de modificar los archivos de diseño originales. Si solo necesitas texto tabular para la ingesta de bases de datos, registro o archivo de texto sin formato, es aún más fácil. Puedes extraer rápidamente el contenido sin procesar de las celdas y escribirlo directamente en un archivo de texto externo con Free Spire.Doc.

Ejemplo de código

from spire.doc import *
from spire.doc.common import *

# Crear una instancia de Document
doc = Document()

# Cargar un documento de Word
doc.LoadFromFile("input.docx")

# Obtener la primera tabla
table = doc.Sections[0].Tables[0]

# Extraer texto de la tabla
tableData = ''
for j in range(table.Rows.Count):
    row = table.Rows.get_Item(j)

    for k in range(row.Cells.Count):
        cell = row.Cells.get_Item(k)

        for p in range(cell.Paragraphs.Count):
            tableData += cell.Paragraphs.get_Item(p).Text + ' '

        if k < row.Cells.Count - 1:
            tableData += '\t'

    tableData += '\n'

# Guardar el texto extraído en un archivo TXT
with open("/table_text.txt", "w", encoding="utf-8") as f:
    f.write(tableData)

doc.Close()

Consejo: Para datos tabulares estructurados, también puedes convertir tablas de Word a CSV para su uso en hojas de cálculo, bases de datos y otros flujos de trabajo de procesamiento de datos.

Preguntas frecuentes

P1: ¿Qué debo hacer si el texto convertido parece desalineado?

El uso de tabulaciones (\t) es lo que mejor conserva el espaciado estructural. Si la alineación de las columnas sigue pareciendo desigual en Word, selecciona los párrafos convertidos y ajusta las tabulaciones en la regla horizontal.

P2: ¿Cómo puedo volver a convertir texto en una tabla en Word?

Para revertir el proceso, resalta tu texto, ve a Insertar > Tabla y haz clic en Convertir texto en tabla. Selecciona el delimitador coincidente (por ejemplo, tabulaciones o comas) para reconstruir tu tabla.

P3: ¿Cuál es la tecla de acceso directo para convertir una tabla a texto en Word?

Microsoft Word no proporciona un atajo de teclado dedicado para Convertir a texto. Puedes acceder al comando a través de la cinta de opciones o personalizar un atajo a través de la configuración de teclado de Word.

Resumen

Este artículo presentó dos formas de convertir tablas en documentos de Word a texto. La herramienta integrada de Word funciona bien para tablas individuales o un pequeño número de documentos, mientras que Free Spire.Doc for Python es más adecuado para el procesamiento automatizado de múltiples tablas. También puedes extraer el contenido de la tabla a un archivo TXT para almacenamiento en texto sin formato o procesamiento posterior.

Leer también:

• ¿Cómo dividir una tabla en Word? (Atajos + VBA + C#)
• Python: Agregar o eliminar filas y columnas de tabla en Word
• Python: Establecer alineación para tablas y texto de tabla en Word
• Python: Eliminar tablas en Word

Word-Tabellen sind nützlich, um Daten zu organisieren, können jedoch unpraktisch werden, wenn Sie deren Inhalte als normalen Text bearbeiten müssen. Wenn Sie die Tabellenstruktur nicht mehr benötigen, können Sie eine Tabelle in Text umwandeln, indem Sie das integrierte Tool von Word verwenden oder den Vorgang mit Python automatisieren. Dieser Leitfaden behandelt detaillierte Schritte für beide Methoden – schauen wir sie uns an.

• Konvertieren von Tabellen in Text in Word mit einem integrierten Tool
• Konvertieren von Word-Tabellen in Text mit Python
  • Konvertieren einer Tabelle in Text
  • Stapelverarbeitung aller Tabellen
• Exportieren von Tabellendaten in eine externe TXT-Datei
• FAQs

Konvertieren von Tabellen in Text in Word mit einem integrierten Tool

Microsoft Word bietet ein integriertes Tool zum Konvertieren von Tabellen in Text. Wenn Sie nur eine oder zwei Tabellen konvertieren müssen, ist das integrierte Tool normalerweise die schnellste Option. Es entfernt die Tabellenstruktur und wandelt den Zelleninhalt in normalen Text um.

So ändern Sie eine Tabelle in Text in MS Word:

• Schritt 1: Klicken Sie irgendwo in die Tabelle, um die kontextbezogene Registerkarte Tabellenlayout im oberen Menüband anzuzeigen.
• Schritt 2: Gehen Sie zur Registerkarte Tabellenlayout im oberen Menü und klicken Sie auf die Schaltfläche In Text konvertieren in der Gruppe Daten.

• Schritt 3: Wählen Sie das gewünschte Trennzeichen (Tabstopps, Kommas, Absatzmarken oder ein benutzerdefiniertes Zeichen), um die Spaltenwerte zu trennen.

• Schritt 4: Klicken Sie auf OK, um die Tabelle sofort in normale Textabsätze umzuwandeln.

Konvertieren in Text vs. Ausblenden von Rahmen

Das Ausblenden von Tabellenrahmen ändert nur das Aussehen der Tabelle. Die Zellen, Spalten und die Tabellenstruktur bleiben erhalten, sodass der Inhalt weiterhin durch das Tabellenlayout eingeschränkt ist.

Das Konvertieren der Tabelle in Text entfernt die Tabellenstruktur und verwandelt den Zelleninhalt in normale Absätze. Sie können den Inhalt dann ohne das Tabellenlayout bearbeiten und formatieren.

Konvertieren von Word-Tabellen in Text mit Python

Das integrierte Tool von Word ist praktisch für die Konvertierung einzelner Tabellen, wird jedoch unpraktisch, wenn Sie viele Dokumente oder Tabellen verarbeiten müssen. Für Python-Entwickler bietet Free Spire.Doc for Python eine Möglichkeit, die Tabellen-zu-Text-Konvertierung zu automatisieren, ohne dass Microsoft Word installiert sein muss.

Konvertieren einer Tabelle in Text

Das Skript liest den Text aus jeder Zelle, verbindet Zellen in derselben Zeile mit Tabstopp-Zeichen, fügt die resultierenden Absätze dort ein, wo sich die Tabelle befand, und entfernt dann die ursprüngliche Tabelle.

from spire.doc import *
from spire.doc.documents import *

# Initialisieren der Document-Instanz und Laden der Zieldatei
doc = Document()
doc.LoadFromFile("input.docx")

# Abrufen des ersten Abschnitts und der Ziel-Tabelle
section = doc.Sections[0]
if section.Tables.Count > 0:
    table = section.Tables[0]

    # Extrahieren von Text aus Zellen Zeile für Zeile
    text_lines = []
    for j in range(table.Rows.Count):
        row = table.Rows.get_Item(j)
        row_cells_text = []
        for k in range(row.Cells.Count):
            cell = row.Cells.get_Item(k)

            # Extrahieren von Text aus Zellenabsätzen
            cell_text_pieces = []
            for p in range(cell.Paragraphs.Count):
                para_obj = cell.Paragraphs.get_Item(p)
                if para_obj.Text:
                    cell_text_pieces.append(para_obj.Text.strip())

            row_cells_text.append(" ".join(cell_text_pieces))

        # Verbinden des Zellentextes mit Tab-Trennzeichen
        text_lines.append("\t".join(row_cells_text))

    # Suchen der Tabelle innerhalb ihres übergeordneten Blocks
    owner_block = table.OwnerTextBody
    table_index = owner_block.ChildObjects.IndexOf(table)

    # Einfügen neuer Textabsätze an der exakten Tabellenposition
    for line in reversed(text_lines):
        temp_para = section.AddParagraph()
        temp_para.Text = line
        section.Paragraphs.Remove(temp_para)
        owner_block.ChildObjects.Insert(table_index, temp_para)

    # Vollständiges Entfernen der Tabellenstruktur aus der Dokumentstruktur
    owner_block.ChildObjects.Remove(table)

# Speichern des aktualisierten Dokuments
doc.SaveToFile("1st table to text.docx", FileFormat.Docx2016)
doc.Close()

Hinweis: Mehrere Absätze innerhalb derselben Zelle werden zu einer einzigen Zeile zusammengefasst, die durch Leerzeichen getrennt ist.

Stapelverarbeitung aller Tabellen

Um alle Tabellen in einem Dokument in Text umzuwandeln, verwenden Sie die Konvertierungslogik aus dem vorherigen Beispiel erneut und wenden Sie sie auf jede Tabelle in jedem Abschnitt an. Da jede Tabelle nach der Konvertierung entfernt wird, sollten die Tabellen in umgekehrter Reihenfolge verarbeitet werden. Andernfalls verschiebt das Löschen einer Tabelle die Indizes der verbleibenden Tabellen, was dazu führen kann, dass Tabellen übersprungen werden oder Indexfehler auftreten.

from spire.doc import *
from spire.doc.documents import *

# Erstellen eines Document-Objekts und Laden einer Word-Datei
doc = Document()
doc.LoadFromFile("input.docx")

# Iterieren durch jeden Abschnitt im Dokument
for s_idx in range(doc.Sections.Count):
    section = doc.Sections[s_idx]

    # Rückwärts durch Tabellen iterieren, um Indexverschiebungen zu vermeiden
    table_count = section.Tables.Count
    for t_idx in range(table_count - 1, -1, -1):
        table = section.Tables.get_Item(t_idx)

        # Sammeln von Text aus allen Zeilen und Zellen
        text_lines = []
        for j in range(table.Rows.Count):
            row = table.Rows.get_Item(j)
            row_cells_text = []
            for k in range(row.Cells.Count):
                cell = row.Cells.get_Item(k)
                cell_text_pieces = []
                for p in range(cell.Paragraphs.Count):
                    para_obj = cell.Paragraphs.get_Item(p)
                    if para_obj.Text:
                        cell_text_pieces.append(para_obj.Text.strip())
                row_cells_text.append(" ".join(cell_text_pieces))
            text_lines.append("\t".join(row_cells_text))

        # Ersetzen des Tabellenknotens durch einfache Absätze an Ort und Stelle
        owner_block = table.OwnerTextBody
        table_index = owner_block.ChildObjects.IndexOf(table)

        for line in reversed(text_lines):
            temp_para = section.AddParagraph()
            temp_para.Text = line
            section.Paragraphs.Remove(temp_para)
            owner_block.ChildObjects.Insert(table_index, temp_para)

        # Sicheres Entfernen der aktuellen Tabelle
        owner_block.ChildObjects.Remove(table)

# Speichern der finalen Datei
doc.SaveToFile("all tables to text.docx", FileFormat.Docx2016)
doc.Close()

Tipp: Exportieren von Tabellendaten in eine externe TXT-Datei

In vielen Daten-Pipelines besteht das Ziel darin, Informationen zu erhalten, anstatt die ursprünglichen Layout-Dateien zu ändern. Wenn Sie tabellarischen Text nur für die Datenbankaufnahme, Protokollierung oder Archivierung als Klartext benötigen, ist dies noch einfacher. Sie können schnell rohe Zelleninhalte extrahieren und diese mit Free Spire.Doc direkt in eine externe Textdatei schreiben.

Codebeispiel

from spire.doc import *
from spire.doc.common import *

# Erstellen einer Document-Instanz
doc = Document()

# Laden eines Word-Dokuments
doc.LoadFromFile("input.docx")

# Abrufen der ersten Tabelle
table = doc.Sections[0].Tables[0]

# Extrahieren von Tabellentext
tableData = ''
for j in range(table.Rows.Count):
    row = table.Rows.get_Item(j)

    for k in range(row.Cells.Count):
        cell = row.Cells.get_Item(k)

        for p in range(cell.Paragraphs.Count):
            tableData += cell.Paragraphs.get_Item(p).Text + ' '

        if k < row.Cells.Count - 1:
            tableData += '\t'

    tableData += '\n'

# Speichern des extrahierten Textes in einer TXT-Datei
with open("/table_text.txt", "w", encoding="utf-8") as f:
    f.write(tableData)

doc.Close()

Tipp: Für strukturierte tabellarische Daten können Sie auch Word-Tabellen in CSV konvertieren, um sie in Tabellenkalkulationen, Datenbanken und anderen Datenverarbeitungs-Workflows zu verwenden.

Häufig gestellte Fragen (FAQs)

F1: Was soll ich tun, wenn der konvertierte Text falsch ausgerichtet aussieht?

Die Verwendung von Tabstopps (\t) bewahrt die strukturelle Abstände am besten. Wenn die Spaltenausrichtung in Word immer noch ungleichmäßig aussieht, markieren Sie die konvertierten Absätze und passen Sie die Tabstopps auf dem horizontalen Lineal an.

F2: Wie kann ich Text in Word wieder in eine Tabelle umwandeln?

Um den Vorgang umzukehren, markieren Sie Ihren Text, gehen Sie zu Einfügen > Tabelle und klicken Sie auf Text in Tabelle konvertieren. Wählen Sie das passende Trennzeichen (z. B. Tabstopps oder Kommas), um Ihre Tabelle neu aufzubauen.

F3: Was ist das Tastenkürzel zum Konvertieren einer Tabelle in Text in Word?

Microsoft Word bietet kein dediziertes Tastenkürzel für In Text konvertieren. Sie können den Befehl über das Menüband aufrufen oder ein Tastenkürzel über die Tastatureinstellungen von Word anpassen.

Zusammenfassung

Dieser Artikel hat zwei Möglichkeiten vorgestellt, Tabellen in Word-Dokumenten in Text umzuwandeln. Das integrierte Tool von Word eignet sich gut für einzelne Tabellen oder eine kleine Anzahl von Dokumenten, während Free Spire.Doc for Python besser für die automatisierte Verarbeitung mehrerer Tabellen geeignet ist. Sie können Tabelleninhalte auch in eine TXT-Datei extrahieren, um sie als Klartext zu speichern oder weiterzuverarbeiten.

Ebenfalls lesen:

• Wie teilt man eine Tabelle in Word? (Tastenkürzel + VBA + C#)
• Python: Hinzufügen oder Löschen von Tabellenzeilen und -spalten in Word
• Python: Ausrichtung für Tabelle und Tabellentext in Word festlegen
• Python: Tabellen in Word entfernen

Таблицы в Word полезны для организации данных, но они могут стать неудобными, когда вам нужно редактировать их содержимое как обычный текст. Если вам больше не нужна структура таблицы, вы можете преобразовать таблицу в текст, используя встроенный инструмент Word, или автоматизировать этот процесс с помощью Python. В этом руководстве подробно описаны оба метода, давайте рассмотрим их.

• Преобразование таблицы в текст в Word с помощью встроенного инструмента
• Преобразование таблиц Word в текст с помощью Python
  • Преобразование таблицы в текст
  • Пакетная обработка всех таблиц
• Экспорт данных таблицы в внешний TXT-файл
• Часто задаваемые вопросы

Преобразование таблицы в текст в Word с помощью встроенного инструмента

Microsoft Word предоставляет встроенный инструмент для преобразования таблиц в текст. Если вам нужно преобразовать всего одну или две таблицы, встроенный инструмент обычно является самым быстрым вариантом. Он удаляет структуру таблицы и преобразует содержимое ячеек в обычный текст.

Как преобразовать таблицу в текст в MS Word:

• Шаг 1: Щелкните в любом месте внутри таблицы, чтобы отобразить контекстную вкладку Макет таблицы (Table Layout) на верхней ленте.
• Шаг 2: Перейдите на вкладку Макет таблицы в верхнем меню и нажмите кнопку Преобразовать в текст (Convert to Text) в группе Данные (Data).

• Шаг 3: Выберите предпочтительный разделитель (знаки табуляции, запятые, знаки абзаца или пользовательский символ) для разделения значений столбцов.

• Шаг 4: Нажмите ОК, чтобы мгновенно преобразовать таблицу в обычные текстовые абзацы.

Преобразование в текст против скрытия границ

Скрытие границ таблицы меняет только внешний вид таблицы. Ячейки, столбцы и структура таблицы остаются на месте, поэтому содержимое по-прежнему ограничено макетом таблицы.

Преобразование таблицы в текст удаляет структуру таблицы и превращает содержимое ячеек в обычные абзацы. После этого вы можете редактировать и форматировать содержимое без ограничений макета таблицы.

Преобразование таблиц Word в текст с помощью Python

Встроенный инструмент Word удобен для преобразования отдельных таблиц, но он становится менее практичным, когда нужно обработать много документов или таблиц. Для разработчиков на Python библиотека Free Spire.Doc for Python предоставляет способ автоматизации преобразования таблицы в текст без необходимости установки Microsoft Word.

Преобразование таблицы в текст

Скрипт считывает текст из каждой ячейки, объединяет ячейки в одной строке с помощью символов табуляции, вставляет полученные абзацы туда, где находилась таблица, а затем удаляет исходную таблицу.

from spire.doc import *
from spire.doc.documents import *

# Инициализация экземпляра документа и загрузка целевого файла
doc = Document()
doc.LoadFromFile("input.docx")

# Получение первого раздела и целевой таблицы
section = doc.Sections[0]
if section.Tables.Count > 0:
    table = section.Tables[0]

    # Извлечение текста из ячеек построчно
    text_lines = []
    for j in range(table.Rows.Count):
        row = table.Rows.get_Item(j)
        row_cells_text = []
        for k in range(row.Cells.Count):
            cell = row.Cells.get_Item(k)

            # Извлечение текста из абзацев ячейки
            cell_text_pieces = []
            for p in range(cell.Paragraphs.Count):
                para_obj = cell.Paragraphs.get_Item(p)
                if para_obj.Text:
                    cell_text_pieces.append(para_obj.Text.strip())

            row_cells_text.append(" ".join(cell_text_pieces))

        # Объединение текста ячеек с использованием разделителей табуляции
        text_lines.append("\t".join(row_cells_text))

    # Определение местоположения таблицы внутри родительского блока
    owner_block = table.OwnerTextBody
    table_index = owner_block.ChildObjects.IndexOf(table)

    # Вставка новых текстовых абзацев точно на место таблицы
    for line in reversed(text_lines):
        temp_para = section.AddParagraph()
        temp_para.Text = line
        section.Paragraphs.Remove(temp_para)
        owner_block.ChildObjects.Insert(table_index, temp_para)

    # Полное удаление структуры таблицы из структуры документа
    owner_block.ChildObjects.Remove(table)

# Сохранение обновленного документа
doc.SaveToFile("1st table to text.docx", FileFormat.Docx2016)
doc.Close()

Примечание: Несколько абзацев внутри одной ячейки объединяются в одну строку, разделенную пробелами.

Пакетная обработка всех таблиц

Чтобы преобразовать все таблицы в документе в текст, используйте логику преобразования из предыдущего примера и примените ее к каждой таблице в каждом разделе. Поскольку каждая таблица удаляется после преобразования, таблицы следует обрабатывать в обратном порядке. В противном случае удаление таблицы смещает индексы оставшихся таблиц, что может привести к пропуску таблиц или ошибкам индексации.

from spire.doc import *
from spire.doc.documents import *

# Создание объекта Document и загрузка файла Word
doc = Document()
doc.LoadFromFile("input.docx")

# Итерация по каждому разделу в документе
for s_idx in range(doc.Sections.Count):
    section = doc.Sections[s_idx]

    # Итерация по таблицам в обратном порядке, чтобы избежать проблем со смещением индексов
    table_count = section.Tables.Count
    for t_idx in range(table_count - 1, -1, -1):
        table = section.Tables.get_Item(t_idx)

        # Сбор текста из всех строк и ячеек
        text_lines = []
        for j in range(table.Rows.Count):
            row = table.Rows.get_Item(j)
            row_cells_text = []
            for k in range(row.Cells.Count):
                cell = row.Cells.get_Item(k)
                cell_text_pieces = []
                for p in range(cell.Paragraphs.Count):
                    para_obj = cell.Paragraphs.get_Item(p)
                    if para_obj.Text:
                        cell_text_pieces.append(para_obj.Text.strip())
                row_cells_text.append(" ".join(cell_text_pieces))
            text_lines.append("\t".join(row_cells_text))

        # Замена узла таблицы на обычные абзацы на месте
        owner_block = table.OwnerTextBody
        table_index = owner_block.ChildObjects.IndexOf(table)

        for line in reversed(text_lines):
            temp_para = section.AddParagraph()
            temp_para.Text = line
            section.Paragraphs.Remove(temp_para)
            owner_block.ChildObjects.Insert(table_index, temp_para)

        # Безопасное удаление текущей таблицы
        owner_block.ChildObjects.Remove(table)

# Сохранение итогового файла
doc.SaveToFile("all tables to text.docx", FileFormat.Docx2016)
doc.Close()

Совет: Экспорт данных таблицы в внешний TXT-файл

Во многих рабочих процессах обработки данных цель состоит в том, чтобы получить информацию, а не изменять исходные файлы макета. Если вам нужен только табличный текст для загрузки в базу данных, ведения журналов или архивирования в виде простого текста, это еще проще. Вы можете быстро извлечь необработанное содержимое ячеек и записать его прямо во внешний текстовый файл с помощью Free Spire.Doc.

Пример кода

from spire.doc import *
from spire.doc.common import *

# Создание экземпляра Document
doc = Document()

# Загрузка документа Word
doc.LoadFromFile("input.docx")

# Получение первой таблицы
table = doc.Sections[0].Tables[0]

# Извлечение текста таблицы
tableData = ''
for j in range(table.Rows.Count):
    row = table.Rows.get_Item(j)

    for k in range(row.Cells.Count):
        cell = row.Cells.get_Item(k)

        for p in range(cell.Paragraphs.Count):
            tableData += cell.Paragraphs.get_Item(p).Text + ' '

        if k < row.Cells.Count - 1:
            tableData += '\t'

    tableData += '\n'

# Сохранение извлеченного текста в TXT-файл
with open("/table_text.txt", "w", encoding="utf-8") as f:
    f.write(tableData)

doc.Close()

Совет: Для структурированных табличных данных вы также можете преобразовать таблицы Word в CSV для использования в электронных таблицах, базах данных и других рабочих процессах обработки данных.

Часто задаваемые вопросы

В1: Что делать, если преобразованный текст выглядит неровно?

Использование табуляции (\t) лучше всего сохраняет структурные интервалы. Если выравнивание столбцов в Word все равно выглядит неровным, выделите преобразованные абзацы и настройте позиции табуляции на горизонтальной линейке.

В2: Как преобразовать текст обратно в таблицу в Word?

Чтобы обратить процесс, выделите текст, перейдите в Вставка > Таблица и нажмите Преобразовать текст в таблицу. Выберите соответствующий разделитель (например, табуляцию или запятые), чтобы восстановить таблицу.

В3: Какая клавиша быстрого доступа для преобразования таблицы в текст в Word?

Microsoft Word не предоставляет специальной клавиши быстрого доступа для команды Преобразовать в текст. Вы можете получить доступ к команде через ленту или настроить сочетание клавиш через настройки клавиатуры Word.

Резюме

В этой статье представлены два способа преобразования таблиц в документах Word в текст. Встроенный инструмент Word хорошо работает для отдельных таблиц или небольшого количества документов, в то время как Free Spire.Doc for Python лучше подходит для автоматизированной обработки нескольких таблиц. Вы также можете извлечь содержимое таблицы в TXT-файл для хранения в виде простого текста или дальнейшей обработки.

Читайте также:

• Как разделить таблицу в Word? (Сочетания клавиш + VBA + C#)
• Python: Добавление или удаление строк и столбцов таблицы в Word
• Python: Установка выравнивания для таблицы и текста таблицы в Word
• Python: Удаление таблиц в Word

Gerar documentos Word a partir de dados do Excel significa usar linhas de uma planilha como fonte para um ou mais arquivos Word estruturados, geralmente seguindo um modelo ou um fluxo de trabalho de geração de documentos. Tradicionalmente, esse trabalho é feito com a Mala Direta do Word: você mapeia colunas do Excel para campos em um modelo .docx e deixa o Word emitir um documento por linha. A mesma tarefa pode ser automatizada em C# com um SDK de documentos, ou levada adiante com um agente de documentos de IA que processa o requisito como uma instrução em linguagem natural. Este artigo compara as rotas, mostra onde a mala direta deixa de ser eficiente e apresenta um exemplo prático em C# construído sobre o Spire.Agent.Office, um SDK de agente de IA para documentos Office.

Navegação Rápida

• O que significa gerar documentos Word a partir de dados do Excel?
• Mala Direta do Excel para o Word
• Três formas de automatizar a geração de Word a partir do Excel no .NET
• Gerar documentos Word personalizados a partir do Excel em C#
• Perguntas Frequentes

1. O que significa gerar documentos Word a partir de dados do Excel?

A frase soa próxima a "converter Excel para Word", mas a intenção é diferente. Converter .xlsx para .docx altera o formato de um arquivo e mantém seu conteúdo aproximadamente igual. Gerar documentos Word a partir de dados do Excel cria novos documentos cujo conteúdo é derivado de células em uma planilha: uma folha de pedido por cliente, um relatório mensal por região, um lote de cartas ou etiquetas a partir de uma lista de endereços, um conjunto de faturas a partir de uma planilha de pedidos.

O formato recorrente do requisito é quase sempre o mesmo:

Como uma frase real, soa assim: "Tenho uma lista de clientes e seus pedidos no Excel; preciso de um documento Word para cada um com suas informações, seus itens e um total." A palavra que importa é derivado: o conteúdo do documento vem dos dados, portanto, trata-se de geração de dados para documento, não de uma simples troca de formato.

Essa é a demanda que este artigo aborda. Tudo abaixo trata das diferentes maneiras de satisfazê-la e do ponto em que você deve parar de vincular campos manualmente.

2. O método tradicional: Mala Direta do Excel para o Word

No nível da interface, a resposta padrão para "transformar esta lista do Excel em vários documentos Word" é a Mala Direta do Word. É o recurso que a maioria das pessoas pensa ao pesquisar a tarefa, e a Microsoft oferece um guia passo a passo para isso. O mecanismo é simples e bem compreendido:

Você coloca um campo como «NomeDoCliente» dentro de um modelo de carta, vincula-o à coluna Cliente da fonte Excel, executa a mesclagem e o Word escreve um documento por linha com esse valor substituído. Como a contagem de linhas pode chegar a milhares, isso transforma "abrir um arquivo, copiar o texto, alterar o nome" em uma operação em lote sem código.

A mala direta é boa em exatamente um tipo de trabalho: colocar esta coluna naquele campo, muitas vezes. Cartas, envelopes, etiquetas e avisos com um layout fixo são sua especialidade. Ela roda dentro do Office, não precisa de programação e, para esses documentos estáveis e baseados apenas em campos, é genuinamente a ferramenta certa.

3. Limites da Mala Direta

O limite chega no momento em que o documento deixa de ser um formulário fixo com espaços em branco e se torna algo que deve depender dos dados. A mala direta substitui valores; ela não decide a estrutura, não raciocina sobre o conteúdo nem compõe nada novo.

Compare dois pedidos. O primeiro é o que a mala direta lida:

"Coloque o nome do cliente no local do nome, o endereço no local do endereço e o pedido nos detalhes do pedido."

O segundo é o pedido que a maioria dos relatórios reais acaba sendo:

"Leia esta pasta de trabalho do Excel, analise os dados de cada cliente, crie um relatório personalizado com seus itens e totais, adicione um resumo de seu padrão de compra e salve cada resultado como um documento Word separado."

O segundo pedido falha em todas as três premissas da mala direta:

• A estrutura varia. Um cliente com três itens de linha precisa de um corpo de documento diferente de um com trinta. Os campos de mesclagem assumem um layout fixo com espaços em branco fixos; eles não aumentam uma tabela com tantas linhas quanto os dados exigem.
• O conteúdo deve ser calculado, não copiado. "Resumir o padrão de compra" e "marcar clientes de alto valor" produzem texto e decisões que nenhuma coluna contém. Não há campo de origem para vinculá-los.
• A saída é um lote de arquivos reais. Cada registro deve ser seu próprio documento Word com seu próprio nome, e o fluxo de trabalho deve ser executado sem supervisão dentro de um aplicativo, não a partir de um assistente do Office.

Essa é a posição honesta da mala direta: ela é excelente no mapeamento de campos, mas torna-se menos adequada quando a estrutura do documento, o conteúdo ou a lógica de saída precisam variar com os dados. O requisito mais profundo — transformar dados em documentos — é um problema de geração, e é onde as rotas de automação abaixo começam.

4. Transformar o requisito em uma instrução: a abordagem via Agente

A alternativa que se ajusta à versão correta do problema é um agente de documentos de IA: uma camada de linguagem natural sobre um motor de documentos determinístico. Em vez de enumerar campos de modelo e código por campo, você descreve a saída, e o agente pode lidar com requisitos difíceis de expressar com a mala direta tradicional — lendo os dados, moldando a estrutura, escrevendo a análise — enquanto o motor de documentos garante que um .docx (ou PDF) real e bem formado seja gerado.

O valor é mais fácil de ver como uma cadeia:

Passos que são difíceis de expressar com a mala direta tradicional — especialmente os três do meio — são exatamente onde um agente pode se destacar. Ele pode interpretar o que uma coluna significa ("Valor Total", "Vendas" e "Líquido" podem nomear o mesmo conceito sob três cabeçalhos), moldar uma estrutura de documento para cada registro e compor os parágrafos de resumo. O que você fornece é uma frase, não um mapa de campos.

A mensagem para levar para o restante deste artigo: a mala direta mapeia colunas do Excel para campos do Word; um agente de IA gera documentos a partir de um requisito. O primeiro é um passo de substituição de valor, o segundo é o que o pedido realmente era.

5. Três formas de automatizar a geração de Word a partir do Excel no .NET

Decidir pela rota certa importa mais do que o código, porque cada rota tem uma curva de custo diferente. Para um aplicativo .NET que precisa deste fluxo de trabalho, as escolhas realistas são:

Um atalho que decide a maioria dos casos:

• O formato nunca muda, um campo por coluna, cartas em massa — mala direta é difícil de superar.
• O formato nunca muda, mas você precisa dele no código, determinístico e testável — use um loop de vinculação de campos via SDK.
• O documento deve variar com os dados, incluir análise ou mudar frequentemente — é aí que um agente de IA se paga, porque o custo de uma alteração muitas vezes pode ser reduzido à atualização da instrução, em vez de alterar a lógica de mapeamento e layout no código.

6. Gerar documentos Word personalizados a partir do Excel em C#

Uma versão concreta e funcional do requisito "um documento Word por registro" é um resumo de pedido de cliente. As entradas são uma pasta de trabalho de pedidos de clientes e um modelo Word leve; a saída é um documento personalizado por cliente. A configuração completa — token, pacote e fiação do projeto — está documentada no tutorial de Introdução; aqui focamos na chamada de geração em si.

using Spire.Doc;
using Spire.Agent.Office.AI;
using Spire.Agent.Office.Extensions;

AIOptions options = new AIOptions
{
    SpireToken = spireToken,
    WorkDir = @"C:\order-ops\output",   // pasta onde os documentos gerados são gravados
    TimeoutMs = 300000
};

using (Document doc = new Document())
{
    // O modelo fornece âncoras por registro; a pasta de trabalho é a fonte de dados.
    doc.LoadFromFile(@"C:\order-ops\templates\order-summary-template.docx");

    // savePath = null: uma instrução produz um documento por registro,
    // gravado na pasta de saída WorkDir. Nenhum loop C# sobre as linhas.
    AIResult result = doc.AI(options).ExecuteInstruction(
        doc,
        "Leia os dados de pedidos de clientes em Q3-orders.xlsx. Gere um resumo " +
        "de pedido Word independente por cliente, linha por linha. Inclua suas informações " +
        "de contato, cada item de linha com quantidade e valor, os totais do pedido, " +
        "e um resumo de um parágrafo de seu padrão de compra. Marque clientes " +
        "cujo total exceda 50.000 como alto valor. Salve cada documento como seu próprio " +
        "arquivo chamado output_ seguido pelo nome do cliente (por exemplo " +
        "output_acme-order-summary.docx).",
        null,
        new[] { @"C:\order-ops\input\Q3-orders.xlsx" });

    if (result == null || !result.Success)
        throw new InvalidOperationException($"A geração falhou: {result?.ErrorMessage}");
}

Três detalhes importam ao executar isso. Primeiro, a instrução é onde a lógica de geração reside: a análise ("resumo de seu padrão de compra"), a lógica condicional ("marcar clientes acima de 50.000") e a estrutura por registro ("cada item de linha"). Segundo, a pasta de trabalho deve estar organizada: a primeira linha é o cabeçalho, um registro por linha, sem linhas vazias ou células de cabeçalho mescladas — as mesmas regras que a fonte de dados do Word espera. Terceiro, o documento base ancora o layout de saída; um documento levemente estruturado pode dar ao agente um ponto de partida útil para a estrutura de cada registro. Com um documento base totalmente vazio, a mesma instrução produz um único documento composto.

Uma regra de nomenclatura importa aqui: os documentos que o agente grava em WorkDir devem começar com o prefixo output_, ou o SDK não os conta como arquivos gerados. É por isso que a instrução acima pede arquivos como output_acme-order-summary.docx em vez de apenas nomes de clientes.

A extensão .docx no seu destino de salvamento ou padrão de arquivo escolhe o formato de saída; aponte a mesma instrução para .pdf e o agente exporta os documentos idênticos para distribuição, sem etapa de renderização separada.

Principais Chamadas de API

• Document.AI(options) -- anexa o processador de documentos de IA a um objeto de documento Word
• ExecuteInstruction(doc, instruction, savePath, attachments) -- executa a geração; null em savePath significa "gravar em WorkDir", e a pasta de trabalho acompanha em attachmentPaths
• AIResult.Success / AIResult.ErrorMessage -- verifica a execução e revela falhas

7. O que você escreveria sem um Agente

Para contraste, a rota de vinculação de campos via SDK para o mesmo trabalho faz tudo explicitamente. O seguinte é intencionalmente simplificado para mostrar a quantidade de lógica de aplicativo envolvida; uma implementação de produção também precisaria carregar e agrupar os dados da pasta de trabalho:

using Spire.Doc;
using Spire.Xls;

// Um formato fixo é bom; cada variação é mais fiação.
foreach (DataRow row in customersTable.Rows)
{
    using (Document doc = new Document())
    {
        doc.LoadFromFile(@"templates\order-summary-template.docx");

        // Localizar-e-substituir por âncora...
        doc.Replace("{{CustomerName}}", row["Customer"].ToString(), true, true);
        doc.Replace("{{TotalAmount}}", row["Amount"].ToString("C"), true, true);

        // Itens de linha vivem em uma segunda planilha: você une manualmente por cliente,
        // constrói uma tabela e insere em um marcador...
        // A regra "marcar clientes de alto valor" é um if/else que você mantém,
        // e o parágrafo de resumo por cliente é um modelo que você escreve à mão.
        doc.SaveToFile($@"out\{row["Customer"]}-order-summary.docx");
    }
    // ... e cada nova regra, coluna ou mudança de layout significa editar isso e recompilar.
}

O agente não remove a necessidade de código — ele remove a necessidade de código de mapeamento e layout. A diferença é onde a lógica reside: em um índice de coluna e um localizar-e-substituir, ou em uma frase que o negócio pode ler e editar. Quando regras de negócio ou estruturas de documento mudam frequentemente, a abordagem de linguagem natural pode reduzir a quantidade de código de mapeamento e layout que deve ser mantida.

8. Onde a IA termina e a lógica de aplicativo começa

Um limite útil não é "o que a IA pode ou não fazer", mas o que o aplicativo deve continuar possuindo. Um agente de geração de documentos fica em cima de código determinístico; ele não o substitui.

Seu aplicativo ainda possui as partes que não têm nada a ver com a compreensão da planilha:

• Descoberta e acesso a arquivos -- encontrar a pasta de trabalho, verificar permissões, preparar entradas
• Agendamento de fluxo de trabalho -- quando o trabalho é executado, em que gatilho, em que ordem
• Controle de fonte de dados -- qual pasta de trabalho é uma entrada autorizada e de onde veio
• Tratamento de erros e novas tentativas -- o que acontece quando um arquivo está faltando ou uma execução falha
• Aprovação final -- um humano revisa os documentos gerados antes que sejam enviados

O agente lida com os passos semânticos:

• Compreensão -- ler o que cada coluna significa de diferentes pastas de trabalho
• Planejamento de estrutura -- determinar quantas seções e linhas o documento precisa
• Análise -- transformar dados de pedidos em um resumo e um sinalizador de alto valor
• Composição -- montar documentos Word personalizados a partir do requisito

Mantenha o encanamento determinístico no código, onde é testável e auditável, e entregue a geração semântica ao agente.

9. Perguntas Frequentes

Isso é um substituto para a mala direta do Word?

Não é um substituto direto; é o mesmo trabalho levado adiante. A mala direta mapeia colunas do Excel em campos fixos do Word, o que é suficiente para uma carta com um formato estável. Um agente de IA pode fazer isso também, e pode ler a pasta de trabalho por conteúdo, moldar a estrutura por registro, adicionar análise e compor texto. Para saídas simples de formato fixo, a mala direta continua sendo uma boa ferramenta; quando o documento deve variar com os dados, o agente carrega mais do trabalho.

Como gero vários documentos Word a partir de dados do Excel?

Passe a pasta de trabalho como anexo, defina o caminho de salvamento como null e aponte AIOptions.WorkDir para uma pasta de saída. Uma ExecuteInstruction com uma instrução linha por linha faz com que o agente produza um documento independente por registro, cada um salvo nessa pasta. Nenhum loop C# sobre as linhas é necessário para o lote por registro.

Posso gerar documentos Word a partir do Excel sem usar a Mala Direta?

Sim. Em C# você pode vincular um modelo com o SDK diretamente, ou entregar a pasta de trabalho a um agente de IA que a lê a partir de uma instrução em linguagem natural, e receber um .docx ou PDF real em troca. A mala direta é uma rota, não a única, e é a menos flexível quando o documento precisa de análise ou seções condicionais.

Qual é a diferença entre Mala Direta e geração de documentos por IA?

A mala direta vincula campos definidos a colunas definidas: coluna do Excel entra, campo do Word sai. A geração de documentos por IA interpreta o pedido e os dados juntos, para que possa interpretar o que cada coluna significa e moldar a estrutura do documento de acordo, produzir conteúdo condicional ou analítico e montar vários documentos a partir de uma instrução.

Posso gerar documentos Word personalizados a partir de um arquivo Excel em C#?

Sim. Carregue um modelo Word ou um documento em branco no Spire.Doc, anexe a pasta de trabalho do Excel e chame ExecuteInstruction com uma descrição da saída personalizada. O agente lê cada registro e compõe um documento ajustado a ele, salvo por registro ou como um arquivo combinado, tudo dentro do seu próprio aplicativo .NET.

Um agente de IA pode usar dados do Excel para gerar documentos Word?

Sim. O Spire.Agent.Office combina um modelo de linguagem com uma camada determinística de Word e Excel, para que a instrução seja compreendida e o resultado ainda seja um arquivo Word real que sua equipe pode abrir, formatar e distribuir.

Pronto para automatizar sua geração de Word?

Se o seu fluxo de trabalho é "dados do Excel tornam-se documentos Word personalizados", o caminho mais rápido é descrever a saída e deixar o agente lidar com o resto. Siga o tutorial de Introdução para executar seu primeiro fluxo de trabalho Word orientado por instruções no .NET.

Leitura Adicional

• Gerar Vários Modelos Word com Spire.Agent.Office -- o mesmo padrão de geração aplicado a diferentes modelos Word
• Automatizando a Análise e Classificação de Notas de Alunos com Spire.Agent.Office -- um fluxo de trabalho do lado do Excel que alimenta os documentos que este artigo gera
• Visão geral do produto Spire.Agent.Office -- SDKs de agente de IA para cada formato de documento Office

Excel 데이터로 Word 문서 생성하기란 스프레드시트의 행을 하나 이상의 구조화된 Word 파일의 소스로 사용하는 것을 의미하며, 일반적으로 템플릿이나 문서 생성 워크플로우를 따릅니다. 전통적으로 이 작업은 Word의 '메일 머지(Mail Merge)' 기능을 통해 처리됩니다. 즉, Excel 열을 .docx 템플릿의 필드에 매핑하여 행당 하나의 문서를 생성하는 방식입니다. 동일한 작업을 C#에서 문서 SDK를 사용하여 자동화하거나, 요구사항을 자연어 지시사항으로 처리하는 AI 문서 에이전트를 활용하여 한 단계 더 발전시킬 수 있습니다. 이 기사에서는 이러한 경로들을 비교하고, 메일 머지의 한계점을 살펴본 뒤, Office 문서용 AI 에이전트 SDK인 Spire.Agent.Office를 기반으로 한 실용적인 C# 예제를 소개합니다.

빠른 탐색

• Excel 데이터로 Word 문서를 생성한다는 것은 무엇인가?
• Excel에서 Word로 메일 머지하기
• .NET에서 Word 생성을 자동화하는 세 가지 방법
• C#에서 Excel로 개인화된 Word 문서 생성하기
• 자주 묻는 질문(FAQ)

1. Excel 데이터로 Word 문서를 생성한다는 것은 무엇인가?

이 문구는 "Excel을 Word로 변환"하는 것과 비슷하게 들리지만, 의도는 다릅니다. .xlsx를 .docx로 변환하는 것은 파일 형식을 바꾸고 내용을 거의 그대로 유지하는 것입니다. 반면, Excel 데이터로 Word 문서를 생성하는 것은 스프레드시트의 셀에서 파생된 콘텐츠로 새로운 문서를 만드는 것입니다. 예를 들어 고객별 주문서, 지역별 월간 보고서, 주소록을 기반으로 한 편지나 라벨 배치, 주문 시트에서 생성된 송장 세트 등이 이에 해당합니다.

이 요구사항의 반복적인 형태는 거의 항상 동일합니다:

실제 문장으로 표현하면 다음과 같습니다: "Excel에 고객 목록과 주문 내역이 있습니다. 각 고객의 정보, 주문 품목, 총액이 포함된 Word 문서를 각각 만들어야 합니다." 여기서 중요한 단어는 파생된(derived)입니다. 문서 콘텐츠가 데이터에서 나오므로, 이는 단순한 형식 전환이 아닌 '데이터 기반 문서 생성'입니다.

이 기사는 바로 이러한 요구를 다룹니다. 아래 내용은 이를 충족하는 다양한 방법과, 더 이상 수동으로 필드를 연결해서는 안 되는 시점에 대해 설명합니다.

2. 전통적인 방식: 메일 머지(Mail Merge)

UI 수준에서 "이 Excel 목록을 여러 개의 Word 문서로 바꾸기"에 대한 기본 답변은 Word 메일 머지입니다. 이 작업을 검색할 때 대부분의 사람들이 생각하는 기능이며, Microsoft에서도 단계별 가이드를 제공합니다. 메커니즘은 간단하고 잘 알려져 있습니다:

편지 템플릿 안에 «CustomerName»과 같은 필드를 배치하고 Excel 소스의 Customer 열에 바인딩한 뒤 머지를 실행하면, Word가 각 행의 값을 대입하여 문서를 작성합니다. 행 수가 수천 개가 될 수 있기 때문에, "파일을 열고 텍스트를 복사하고 이름을 바꾸는" 작업을 코딩 없이 일괄 처리로 바꿔줍니다.

메일 머지는 "이 열을 저 필드에 여러 번 넣는" 작업에 최적화되어 있습니다. 고정된 레이아웃을 가진 편지, 봉투, 라벨, 통지서가 주 영역입니다. Office 내에서 실행되며 프로그래밍이 필요 없고, 필드만 사용하는 안정적인 문서에는 확실히 올바른 도구입니다.

3. 메일 머지의 한계

문서가 빈칸이 있는 고정된 양식에서 벗어나 데이터에 따라 달라져야 하는 순간 한계가 찾아옵니다. 메일 머지는 값을 대체할 뿐, 구조를 결정하거나 내용을 추론하거나 새로운 것을 구성하지 못합니다.

두 가지 요청을 비교해 보겠습니다. 첫 번째는 메일 머지가 처리하는 방식입니다:

"고객 이름을 이름 칸에, 주소를 주소 칸에, 주문 내역을 주문 상세 칸에 넣으세요."

두 번째는 실제 보고서에서 흔히 요구되는 방식입니다:

"이 Excel 통합 문서를 읽고, 각 고객의 데이터를 분석하여 품목과 총액이 포함된 개인화된 보고서를 만들고, 구매 패턴 요약을 추가한 뒤, 각 결과를 별도의 Word 문서로 저장하세요."

두 번째 요청은 메일 머지의 세 가지 가정 때문에 실패합니다:

• 구조가 가변적입니다. 품목이 3개인 고객과 30개인 고객은 문서 본문이 달라야 합니다. 머지 필드는 고정된 레이아웃과 빈칸을 가정하므로, 데이터가 요구하는 만큼 표의 행을 늘릴 수 없습니다.
• 내용은 복사가 아닌 계산이 필요합니다. "구매 패턴 요약"이나 "우수 고객 표시"는 어떤 열에도 존재하지 않는 텍스트와 판단을 생성합니다. 바인딩할 소스 필드가 없습니다.
• 출력물은 실제 파일들의 배치입니다. 각 레코드는 고유한 이름을 가진 별도의 Word 문서여야 하며, 워크플로우는 Office 마법사가 아닌 애플리케이션 내에서 무인으로 실행되어야 합니다.

이것이 메일 머지의 솔직한 위치입니다. 필드 매핑에는 탁월하지만, 문서 구조, 내용, 출력 로직이 데이터에 따라 달라져야 할 때는 적합하지 않습니다. 더 깊은 요구사항인 데이터를 문서로 바꾸는 것은 생성(Generation)의 문제이며, 아래의 자동화 경로가 시작되는 지점입니다.

4. 요구사항을 지시사항으로: 에이전트 방식

이 문제의 올바른 버전에 맞는 대안은 AI 문서 에이전트입니다. 이는 결정론적 문서 엔진 위에 자연어 레이어를 얹은 것입니다. 템플릿 필드와 필드별 코드를 일일이 나열하는 대신, 출력물을 설명하면 에이전트가 데이터 읽기, 구조 형성, 분석 작성 등 메일 머지로 표현하기 어려운 요구사항을 처리합니다. 동시에 문서 엔진은 잘 구성된 .docx(또는 PDF) 파일이 생성되도록 보장합니다.

그 가치는 체인 형태로 보면 더 쉽게 이해됩니다:

전통적인 메일 머지로 표현하기 어려운 단계들, 특히 중간의 세 단계는 에이전트가 제 역할을 하는 곳입니다. 에이전트는 열이 무엇을 의미하는지 해석하고("총액", "매출", "순액"이 같은 개념일 수 있음), 각 레코드에 맞게 문서 구조를 형성하며, 요약 단락을 구성할 수 있습니다. 여러분이 제공하는 것은 필드 맵이 아니라 문장입니다.

이 기사의 핵심 메시지는 다음과 같습니다: 메일 머지는 Excel 열을 Word 필드에 매핑하고, AI 에이전트는 요구사항으로부터 문서를 생성합니다. 전자는 값 대체 단계이고, 후자는 실제 요청사항을 수행하는 것입니다.

5. .NET에서 Word 생성을 자동화하는 세 가지 방법

각 경로마다 비용 곡선이 다르기 때문에 코드보다 올바른 경로를 선택하는 것이 더 중요합니다. 이 워크플로우가 필요한 .NET 애플리케이션의 현실적인 선택지는 다음과 같습니다:

대부분의 경우를 결정하는 지름길:

• 형태가 절대 변하지 않고, 열당 필드 하나, 대량 편지 발송 -- 메일 머지가 최고입니다.
• 형태는 변하지 않지만 코드로 제어해야 하고, 결정론적이며 테스트 가능해야 함 -- SDK 필드 바인딩 루프를 사용하세요.
• 문서가 데이터에 따라 달라져야 하거나, 분석이 포함되거나, 자주 변경됨 -- AI 에이전트가 비용 효율적입니다. 코드의 매핑 및 레이아웃 로직을 변경하는 대신 지시사항만 업데이트하면 되기 때문입니다.

6. C#에서 Excel로 개인화된 Word 문서 생성하기

"레코드당 하나의 Word 문서"라는 요구사항에 대한 구체적이고 작동하는 예시는 고객 주문 요약입니다. 입력값은 고객 주문 통합 문서와 가벼운 Word 템플릿이며, 출력값은 고객별 개인화된 문서입니다. 전체 설정(토큰, 패키지, 프로젝트 연결)은 시작하기(Getting Started) 튜토리얼에 문서화되어 있으며, 여기서는 생성 호출 자체에 집중합니다.

using Spire.Doc;
using Spire.Agent.Office.AI;
using Spire.Agent.Office.Extensions;

AIOptions options = new AIOptions
{
    SpireToken = spireToken,
    WorkDir = @"C:\order-ops\output",   // 생성된 문서가 저장될 폴더
    TimeoutMs = 300000
};

using (Document doc = new Document())
{
    // 템플릿은 레코드별 앵커를 제공하고, 통합 문서는 데이터 소스입니다.
    doc.LoadFromFile(@"C:\order-ops\templates\order-summary-template.docx");

    // savePath = null: 하나의 지시사항이 레코드당 하나의 문서를 생성하여
    // WorkDir 출력 폴더에 저장합니다. 행에 대한 C# 루프가 필요 없습니다.
    AIResult result = doc.AI(options).ExecuteInstruction(
        doc,
        "Q3-orders.xlsx의 고객 주문 데이터를 읽으세요. 고객별로 독립적인 " +
        "Word 주문 요약서를 행 단위로 생성하세요. 연락처 정보, 수량과 금액이 포함된 " +
        "모든 품목, 주문 총액, 그리고 구매 패턴에 대한 한 단락의 요약을 포함하세요. " +
        "총액이 50,000을 초과하는 고객은 우수 고객으로 표시하세요. 각 문서를 " +
        "output_ 뒤에 고객 이름을 붙인 파일로 저장하세요 (예: " +
        "output_acme-order-summary.docx).",
        null,
        new[] { @"C:\order-ops\input\Q3-orders.xlsx" });

    if (result == null || !result.Success)
        throw new InvalidOperationException($"생성 실패: {result?.ErrorMessage}");
}

직접 실행할 때 세 가지 세부 사항이 중요합니다. 첫째, 지시사항에 생성 로직이 포함됩니다(분석, 조건부 로직, 레코드별 구조). 둘째, 통합 문서는 깔끔해야 합니다(첫 행은 헤더, 행당 하나의 레코드, 빈 행이나 병합된 헤더 셀 없음). 셋째, 기본 문서는 출력 레이아웃의 기준이 됩니다. 완전히 빈 기본 문서를 사용하면 동일한 지시사항으로 단일 구성 문서를 생성할 수 있습니다.

명명 규칙도 중요합니다. 에이전트가 WorkDir에 작성하는 문서는 output_ 접두사로 시작해야 하며, 그렇지 않으면 SDK는 이를 생성된 파일로 간주하지 않습니다.

저장 대상이나 파일 패턴의 .docx 확장자가 출력 형식을 결정합니다. 동일한 지시사항을 .pdf로 지정하면 에이전트가 별도의 렌더링 단계 없이 배포용으로 동일한 문서를 내보냅니다.

주요 API 호출

• Document.AI(options) -- AI 문서 프로세서를 Word 문서 객체에 연결
• ExecuteInstruction(doc, instruction, savePath, attachments) -- 생성 실행; savePath가 null이면 WorkDir에 저장하며, 통합 문서는 attachmentPaths에 포함됨
• AIResult.Success / AIResult.ErrorMessage -- 실행 확인 및 실패 처리

7. 에이전트 없이 구현할 경우

대조적으로, 동일한 작업에 대한 SDK 필드 바인딩 경로는 모든 것을 명시적으로 수행합니다. 다음은 애플리케이션 로직의 양을 보여주기 위해 의도적으로 단순화된 예시입니다:

using Spire.Doc;
using Spire.Xls;

// 고정된 형태는 괜찮지만, 변경될 때마다 더 많은 코딩이 필요합니다.
foreach (DataRow row in customersTable.Rows)
{
    using (Document doc = new Document())
    {
        doc.LoadFromFile(@"templates\order-summary-template.docx");

        // 앵커별 찾기-바꾸기...
        doc.Replace("{{CustomerName}}", row["Customer"].ToString(), true, true);
        doc.Replace("{{TotalAmount}}", row["Amount"].ToString("C"), true, true);

        // 품목은 두 번째 시트에 있음: 고객별로 직접 조인하고,
        // 표를 만들고, 책갈피에 삽입해야 함...
        // "우수 고객 표시" 규칙은 직접 유지 관리하는 if/else이며,
        // 고객별 요약 단락은 직접 작성해야 하는 템플릿임.
        doc.SaveToFile($@"out\{row["Customer"]}-order-summary.docx");
    }
    // ... 새로운 규칙, 열, 레이아웃 변경마다 이 코드를 수정하고 재컴파일해야 함.
}

에이전트가 코드의 필요성을 없애는 것은 아니지만, 매핑 및 레이아웃 코드의 필요성을 없애줍니다. 차이점은 로직이 어디에 있느냐입니다. 비즈니스 규칙이나 문서 구조가 자주 변경될 때, 자연어 접근 방식은 유지 관리해야 할 매핑 및 레이아웃 코드의 양을 줄일 수 있습니다.

8. AI의 역할과 애플리케이션 로직의 경계

유용한 경계는 "AI가 할 수 있는 것과 없는 것"이 아니라 애플리케이션이 계속 소유해야 할 것입니다. 문서 생성 에이전트는 결정론적 코드 위에 위치하며, 이를 대체하지 않습니다.

애플리케이션은 여전히 스프레드시트 이해와 관련 없는 부분을 소유합니다:

• 파일 탐색 및 액세스 -- 통합 문서 찾기, 권한 확인, 입력 준비
• 워크플로우 스케줄링 -- 작업 실행 시점, 트리거, 순서
• 데이터 소스 제어 -- 승인된 입력 통합 문서가 무엇인지 확인
• 오류 처리 및 재시도 -- 파일이 없거나 실행 실패 시 처리
• 최종 승인 -- 배포 전 사람이 생성된 문서를 검토

에이전트는 의미론적 단계를 처리합니다:

• 이해 -- 다양한 통합 문서에서 각 열이 무엇을 의미하는지 읽기
• 구조 계획 -- 문서에 필요한 섹션과 행 수 결정
• 분석 -- 주문 데이터를 요약 및 우수 고객 플래그로 변환
• 구성 -- 요구사항으로부터 개인화된 Word 문서 조립

결정론적 배관(plumbing)은 테스트 및 감사가 가능한 코드에 유지하고, 의미론적 생성은 에이전트에게 맡기십시오. 각 측면은 자신이 잘하는 일을 수행합니다.

9. 자주 묻는 질문(FAQ)

이것이 Word 메일 머지를 대체하나요?

완벽한 대체제라기보다는 동일한 작업을 더 발전시킨 것입니다. 메일 머지는 Excel 열을 고정된 Word 필드에 매핑하며, 이는 안정적인 형태의 편지에 충분합니다. AI 에이전트는 그 기능은 물론, 콘텐츠별로 통합 문서를 읽고, 레코드별로 구조를 형성하며, 분석을 추가하고, 산문을 구성할 수 있습니다. 단순한 고정 형태 출력에는 메일 머지가 여전히 좋은 도구이며, 문서가 데이터에 따라 달라져야 할 때 에이전트가 더 많은 역할을 수행합니다.

Excel 데이터에서 여러 개의 Word 문서를 어떻게 생성하나요?

통합 문서를 첨부 파일로 전달하고, 저장 경로를 null로 설정한 뒤 AIOptions.WorkDir을 출력 폴더로 지정하십시오. 행별 지시사항이 포함된 ExecuteInstruction 하나로 에이전트가 레코드당 독립적인 문서를 생성하여 해당 폴더에 저장합니다. 레코드별 배치를 위해 행에 대한 C# 루프를 작성할 필요가 없습니다.

메일 머지를 사용하지 않고 Excel에서 Word 문서를 생성할 수 있나요?

네. C#에서 SDK로 템플릿을 직접 바인딩하거나, 자연어 지시사항으로 통합 문서를 읽는 AI 에이전트에 전달하여 .docx 또는 PDF를 받을 수 있습니다. 메일 머지는 하나의 경로일 뿐이며, 문서에 분석이나 조건부 섹션이 필요할 때 가장 유연성이 떨어집니다.

메일 머지와 AI 문서 생성의 차이점은 무엇인가요?

메일 머지는 정의된 필드를 정의된 열에 바인딩합니다(Excel 열 입력 -> Word 필드 출력). AI 문서 생성은 요청과 데이터를 함께 해석하므로 각 열의 의미를 파악하고 그에 따라 문서 구조를 형성하며, 조건부 또는 분석적 콘텐츠를 생성하고, 하나의 지시사항으로 여러 문서를 조립할 수 있습니다. 전자는 매핑 단계이고, 후자는 생성 작업입니다.

C#에서 Excel 파일로 개인화된 Word 문서를 생성할 수 있나요?

네. Word 템플릿이나 빈 문서를 Spire.Doc에 로드하고, Excel 통합 문서를 첨부한 뒤 개인화된 출력물에 대한 설명과 함께 ExecuteInstruction을 호출하십시오. 에이전트가 각 레코드를 읽고 그에 맞게 조정된 문서를 구성하여 레코드별로 저장하거나 하나의 결합된 파일로 저장합니다.

AI 에이전트가 Excel 데이터를 사용하여 Word 문서를 생성할 수 있나요?

네. Spire.Agent.Office는 언어 모델과 결정론적인 Word 및 Excel 레이어를 결합하므로, 지시사항이 이해되고 결과물은 팀이 열고 형식화하고 배포할 수 있는 실제 Word 파일이 됩니다. 에이전트는 고정된 열 매핑에 의존하는 대신 스프레드시트의 콘텐츠를 해석하므로 이기종 입력도 처리할 수 있습니다.

Word 생성 자동화를 시작할 준비가 되셨나요?

워크플로우가 "Excel 데이터가 개인화된 Word 문서로 변환"되는 것이라면, 가장 빠른 경로는 출력물을 설명하고 에이전트가 나머지를 처리하게 하는 것입니다. 시작하기(Getting Started) 튜토리얼을 따라 .NET에서 첫 번째 지시사항 기반 Word 워크플로우를 실행해 보십시오.

추가 읽기

• Spire.Agent.Office로 다양한 Word 템플릿 생성하기 -- 다양한 Word 템플릿에 적용된 동일한 생성 패턴
• Spire.Agent.Office로 학생 성적 분석 및 순위 자동화하기 -- 이 기사에서 생성하는 문서에 데이터를 공급하는 Excel 측 워크플로우
• Spire.Agent.Office 제품 개요 -- 모든 Office 문서 형식을 위한 AI 에이전트 SDK