Примеры кодирования строк base64

Базовое кодирование и декодирование строки в Base64

// Преобразование обычной строки в Base64 и обратно
Процедура БазовоеКодированиеBase64()

    ИсходнаяСтрока = "Привет, мир! Hello, World!";
    Сообщить("Исходная строка: " + ИсходнаяСтрока);
    
    // Кодирование в Base64
    Кодировка = КодировкаТекста.UTF8;
    ДвоичныеДанные = ПолучитьДвоичныеДанныеИзСтроки(ИсходнаяСтрока, Кодировка);
    Base64Строка = ПолучитьСтрокуИзДвоичныхДанных(ДвоичныеДанные, КодировкаТекста.Base64);
    
    Сообщить("Base64: " + Base64Строка);
    
    // Декодирование из Base64
    ДвоичныеДанныеИзBase64 = ПолучитьДвоичныеДанныеИзСтроки(Base64Строка, КодировкаТекста.Base64);
    ВосстановленнаяСтрока = ПолучитьСтрокуИзДвоичныхДанных(ДвоичныеДанныеИзBase64, Кодировка);
    
    Сообщить("Декодированная строка: " + ВосстановленнаяСтрока);
    
    // Проверка соответствия
    Если ИсходнаяСтрока = ВосстановленнаяСтрока Тогда
        Сообщить("Кодирование/декодирование выполнено успешно");
    КонецЕсли;
    
КонецПроцедуры

Кодирование файла в Base64 (для передачи по HTTP)

// Чтение файла и преобразование его содержимого в Base64 строку
Процедура КодироватьФайлВBase64()

    // Создаем тестовый файл
    ИмяФайла = "C:\Temp\test.txt";
    ТекстФайла = "Это содержимое текстового файла, которое будет закодировано в Base64";
    
    Запись = Новый ЗаписьТекста(ИмяФайла, КодировкаТекста.UTF8);
    Запись.Записать(ТекстФайла);
    Запись.Закрыть();
    
    // Читаем файл как двоичные данные
    ДвоичныеДанныеФайла = Новый ДвоичныеДанные(ИмяФайла);
    
    // Кодируем в Base64
    Base64Строка = ПолучитьСтрокуИзДвоичныхДанных(ДвоичныеДанныеФайла, КодировкаТекста.Base64);
    
    Сообщить("Размер файла: " + ДвоичныеДанныеФайла.Размер() + " байт");
    Сообщить("Base64 длина: " + СтрДлина(Base64Строка) + " символов");
    Сообщить("Base64 (первые 100 символов): " + Лев(Base64Строка, 100) + "...");
    
    // Сохраняем Base64 в файл (например, для передачи)
    ИмяBase64Файла = "C:\Temp\test_base64.txt";
    ЗаписьBase64 = Новый ЗаписьТекста(ИмяBase64Файла, КодировкаТекста.UTF8);
    ЗаписьBase64.Записать(Base64Строка);
    ЗаписьBase64.Закрыть();
    
    Сообщить("Base64 строка сохранена в: " + ИмяBase64Файла);
    
    // Декодируем обратно в файл
    ДвоичныеДанныеИзBase64 = ПолучитьДвоичныеДанныеИзСтроки(Base64Строка, КодировкаТекста.Base64);
    ВосстановленныйФайл = "C:\Temp\restored_test.txt";
    ДвоичныеДанныеИзBase64.Записать(ВосстановленныйФайл);
    
    Сообщить("Восстановленный файл: " + ВосстановленныйФайл);
    
КонецПроцедуры

Кодирование и декодирование с разными кодировками

// Работа с Base64 для текста в различных кодировках
Процедура Base64СРазнымиКодировками()

    ИсходныйТекст = "Русский текст English text 123 !@#";
    
    // Кодировка UTF-8 (стандартная)
    ДвоичныеUTF8 = ПолучитьДвоичныеДанныеИзСтроки(ИсходныйТекст, КодировкаТекста.UTF8);
    Base64UTF8 = ПолучитьСтрокуИзДвоичныхДанных(ДвоичныеUTF8, КодировкаТекста.Base64);
    
    // Кодировка ANSI (системная)
    ДвоичныеANSI = ПолучитьДвоичныеДанныеИзСтроки(ИсходныйТекст, КодировкаТекста.ANSI);
    Base64ANSI = ПолучитьСтрокуИзДвоичныхДанных(ДвоичныеANSI, КодировкаТекста.Base64);
    
    // Кодировка UTF-16
    ДвоичныеUTF16 = ПолучитьДвоичныеДанныеИзСтроки(ИсходныйТекст, КодировкаТекста.UTF16);
    Base64UTF16 = ПолучитьСтрокуИзДвоичныхДанных(ДвоичныеUTF16, КодировкаТекста.Base64);
    
    Сообщить("Исходная строка: " + ИсходныйТекст);
    Сообщить("Base64 (UTF-8): " + Base64UTF8);
    Сообщить("Base64 (ANSI): " + Base64ANSI);
    Сообщить("Base64 (UTF-16): " + Лев(Base64UTF16, 50) + "...");
    
    // Декодирование с указанием правильной кодировки
    ДвоичныеДляДекода = ПолучитьДвоичныеДанныеИзСтроки(Base64UTF8, КодировкаТекста.Base64);
    ВосстановленныйUTF8 = ПолучитьСтрокуИзДвоичныхДанных(ДвоичныеДляДекода, КодировкаТекста.UTF8);
    
    Сообщить("Восстановлено (UTF-8): " + ВосстановленныйUTF8);
    
    // Пример неправильной кодировки (показывает кракозябры)
    ВосстановленныйANSI = ПолучитьСтрокуИзДвоичныхДанных(ДвоичныеДляДекода, КодировкаТекста.ANSI);
    Сообщить("Восстановлено (ANSI, некорректно): " + ВосстановленныйANSI);
    
КонецПроцедуры

Кодирование изображения в Base64 (для вставки в HTML)

// Преобразование изображения в Base64 для использования в HTML (data:image)
Процедура ИзображениеВBase64()

    // Путь к изображению (создадим тестовое)
    ПутьКИзображению = "C:\Temp\test.png";
    
    // Создаем простой BMP файл (для примера)
    СоздатьТестовоеИзображение(ПутьКИзображению);
    
    // Читаем изображение как двоичные данные
    Попытка
        ДвоичныеДанные = Новый ДвоичныеДанные(ПутьКИзображению);
        Сообщить("Размер изображения: " + ДвоичныеДанные.Размер() + " байт");
        
        // Кодируем в Base64
        Base64Строка = ПолучитьСтрокуИзДвоичныхДанных(ДвоичныеДанные, КодировкаТекста.Base64);
        
        // Формируем HTML-тэг с встроенным изображением
        // Определяем MIME-тип по расширению
        MIMETип = "image/png";
        HTMLТег = "<img src='data:" + MIMETип + ";base64," + Base64Строка + "' alt='Изображение'>";
        
        // Сохраняем HTML файл
        HTMLФайл = "C:\Temp\image_base64.html";
        ЗаписьHTML = Новый ЗаписьТекста(HTMLФайл, КодировкаТекста.UTF8);
        ЗаписьHTML.ЗаписатьСтроку("<!DOCTYPE html>");
        ЗаписьHTML.ЗаписатьСтроку("<html><body>");
        ЗаписьHTML.ЗаписатьСтроку("<h2>Изображение в Base64</h2>");
        ЗаписьHTML.ЗаписатьСтроку(HTMLТег);
        ЗаписьHTML.ЗаписатьСтроку("</body></html>");
        ЗаписьHTML.Закрыть();
        
        Сообщить("HTML файл создан: " + HTMLФайл);
        Сообщить("Длина Base64 строки: " + СтрДлина(Base64Строка) + " символов");
        
    Исключение
        Сообщить("Ошибка: " + ОписаниеОшибки());
    КонецПопытки;
    
КонецПроцедуры

Процедура СоздатьТестовоеИзображение(ПутьКФайлу)
    // Создаем простой BMP файл 1x1 пиксель (минимальный)
    Данные = Новый ДвоичныеДанные;
    // Заголовок BMP (упрощенно)
    // В реальном коде здесь должны быть корректные байты BMP
    // Для примера используем существующий файл или пропускаем
    Сообщить("Для реального использования укажите путь к существующему изображению");
КонецПроцедуры

Передача Base64 через HTTP-запрос (POST)

// Формирование Base64 строки для отправки в теле HTTP-запроса
Процедура ОтправитьBase64ЧерезHTTP()

    // Подготавливаем данные для отправки
    ДанныеДляОтправки = Новый Структура;
    ДанныеДляОтправки.Вставить("Название", "Тестовый документ");
    ДанныеДляОтправки.Вставить("Дата", ТекущаяДата());
    ДанныеДляОтправки.Вставить("Содержимое", "Текст документа для отправки");
    
    // Преобразуем структуру в JSON
    ЗаписьJSON = Новый ЗаписьJSON;
    ЗаписьJSON.УстановитьСтроку();
    ЗаписатьJSON(ЗаписьJSON, ДанныеДляОтправки);
    JSONСтрока = ЗаписьJSON.Закрыть();
    
    // Кодируем JSON в Base64 (для безопасной передачи)
    ДвоичныеJSON = ПолучитьДвоичныеДанныеИзСтроки(JSONСтрока, КодировкаТекста.UTF8);
    Base64Данные = ПолучитьСтрокуИзДвоичныхДанных(ДвоичныеJSON, КодировкаТекста.Base64);
    
    Сообщить("Исходный JSON: " + JSONСтрока);
    Сообщить("Base64: " + Лев(Base64Данные, 100) + "...");
    
    // Формирование HTTP-запроса
    HTTPСоединение = Новый HTTPСоединение("api.example.com");
    
    // Создаем тело запроса
    ТелоЗапроса = Новый Структура;
    ТелоЗапроса.Вставить("dataType", "base64");
    ТелоЗапроса.Вставить("contentType", "application/json");
    ТелоЗапроса.Вставить("data", Base64Данные);
    
    ЗаписьJSON2 = Новый ЗаписьJSON;
    ЗаписьJSON2.УстановитьСтроку();
    ЗаписатьJSON(ЗаписьJSON2, ТелоЗапроса);
    Тело = ЗаписьJSON2.Закрыть();
    
    Сообщить("Тело запроса готово к отправке");
    
    // Декодирование на стороне сервера (эмуляция)
    // (В реальном коде здесь был бы HTTP запрос)
    ЭмуляцияДекодированияНаСервере(Base64Данные);
    
КонецПроцедуры

Процедура ЭмуляцияДекодированияНаСервере(Base64Строка)
    // Декодируем Base64 обратно
    ДвоичныеДанные = ПолучитьДвоичныеДанныеИзСтроки(Base64Строка, КодировкаТекста.Base64);
    ДекодированныйТекст = ПолучитьСтрокуИзДвоичныхДанных(ДвоичныеДанные, КодировкаТекста.UTF8);
    
    // Парсим JSON
    ЧтениеJSON = Новый ЧтениеJSON;
    ЧтениеJSON.УстановитьСтроку(ДекодированныйТекст);
    ВосстановленныеДанные = ПрочитатьJSON(ЧтениеJSON);
    ЧтениеJSON.Закрыть();
    
    Сообщить("Сервер декодировал данные:");
    Сообщить("Название: " + ВосстановленныеДанные.Название);
    Сообщить("Содержимое: " + ВосстановленныеДанные.Содержимое);
КонецПроцедуры

Массовое кодирование файлов в каталоге

// Пакетное преобразование всех файлов в каталоге в Base64
Процедура МассовоеКодированиеФайловВBase64()

    // Каталог с исходными файлами
    ИсходныйКаталог = "C:\Temp\Source\";
    КаталогРезультатов = "C:\Temp\Base64Results\";
    
    // Создаем каталоги
    Если Не КаталогСуществует(ИсходныйКаталог) Тогда
        СоздатьКаталог(ИсходныйКаталог);
    КонецЕсли;
    
    Если Не КаталогСуществует(КаталогРезультатов) Тогда
        СоздатьКаталог(КаталогРезультатов);
    КонецЕсли;
    
    // Создаем тестовые файлы
    Для Инд = 1 По 3 Цикл
        ИмяФайла = ИсходныйКаталог + "file" + Строка(Инд) + ".txt";
        Запись = Новый ЗаписьТекста(ИмяФайла, КодировкаТекста.UTF8);
        Запись.ЗаписатьСтроку("Содержимое файла " + Строка(Инд) + 
                               " для массового кодирования");
        Запись.Закрыть();
    КонецЦикла;
    
    // Находим все файлы в каталоге
    НайтиФайлы = Новый НайтиФайлы;
    НайтиФайлы.НайтиФайлы(ИсходныйКаталог, "*.*", Истина);
    
    // Создаем таблицу результатов
    Результаты = Новый ТаблицаЗначений;
    Результаты.Колонки.Добавить("ИсходныйФайл");
    Результаты.Колонки.Добавить("Base64Файл");
    Результаты.Колонки.Добавить("Размер", Новый ОписаниеТипов("Число"));
    Результаты.Колонки.Добавить("РазмерBase64", Новый ОписаниеТипов("Число"));
    
    // Обрабатываем каждый файл
    Для Каждого Файл Из НайтиФайлы.Файлы Цикл
        Попытка
            // Читаем файл
            ДвоичныеДанные = Новый ДвоичныеДанные(Файл.ПолноеИмя);
            
            // Кодируем в Base64
            Base64Строка = ПолучитьСтрокуИзДвоичныхДанных(ДвоичныеДанные, КодировкаТекста.Base64);
            
            // Сохраняем Base64 в отдельный файл
            ИмяBase64Файла = КаталогРезультатов + Файл.Имя + ".base64.txt";
            ЗаписьBase64 = Новый ЗаписьТекста(ИмяBase64Файла, КодировкаТекста.UTF8);
            ЗаписьBase64.Записать(Base64Строка);
            ЗаписьBase64.Закрыть();
            
            // Записываем результат
            НоваяСтрока = Результаты.Добавить();
            НоваяСтрока.ИсходныйФайл = Файл.ПолноеИмя;
            НоваяСтрока.Base64Файл = ИмяBase64Файла;
            НоваяСтрока.Размер = ДвоичныеДанные.Размер();
            НоваяСтрока.РазмерBase64 = СтрДлина(Base64Строка);
            
            Сообщить("Обработан: " + Файл.Имя);
            
        Исключение
            Сообщить("Ошибка при обработке файла " + Файл.Имя + ": " + ОписаниеОшибки());
        КонецПопытки;
    КонецЦикла;
    
    // Выводим статистику
    Сообщить("Обработка завершена. Обработано файлов: " + Результаты.Количество());
    
    ОбщийРазмер = 0;
    ОбщийРазмерBase64 = 0;
    
    Для Каждого Строка Из Результаты Цикл
        ОбщийРазмер = ОбщийРазмер + Строка.Размер;
        ОбщийРазмерBase64 = ОбщийРазмерBase64 + Строка.РазмерBase64;
    КонецЦикла;
    
    Сообщить("Общий размер исходных файлов: " + ОбщийРазмер + " байт");
    Сообщить("Общий размер Base64 файлов: " + ОбщийРазмерBase64 + " байт");
    Сообщить("Увеличение размера: ~" + Окр(ОбщийРазмерBase64 / ОбщийРазмер * 100 - 100, 2) + "%");
    
    // Сохраняем отчет
    ОтчетФайл = КаталогРезультатов + "report.csv";
    ЗаписьCSV = Новый ЗаписьТекста(ОтчетФайл, КодировкаТекста.UTF8);
    ЗаписьCSV.ЗаписатьСтроку("Исходный файл;Размер;Base64 файл;Размер Base64;Коэффициент");
    
    Для Каждого Строка Из Результаты Цикл
        Коэффициент = Окр(Строка.РазмерBase64 / Строка.Размер, 2);
        СтрокаCSV = Строка.ИсходныйФайл + ";" + 
                    Строка.Размер + ";" +
                    Строка.Base64Файл + ";" +
                    Строка.РазмерBase64 + ";" +
                    Строка(Коэффициент);
        ЗаписьCSV.ЗаписатьСтроку(СтрокаCSV);
    КонецЦикла;
    
    ЗаписьCSV.Закрыть();
    Сообщить("Отчет сохранен: " + ОтчетФайл);
    
КонецПроцедуры

Сжатие данных перед кодированием в Base64

// Сжатие строки перед Base64 для уменьшения размера
Процедура СжатиеИBase64()

    // Исходные данные (большой текст)
    ИсходнаяСтрока = "";
    Для Инд = 1 По 1000 Цикл
        ИсходнаяСтрока = ИсходнаяСтрока + "Это длинная строка для тестирования сжатия перед кодированием в Base64. ";
    КонецЦикла;
    
    Сообщить("Исходная строка (размер в байтах): " + СтрДлина(ИсходнаяСтрока));
    
    // Способ 1: обычное Base64
    ДвоичныеДанные = ПолучитьДвоичныеДанныеИзСтроки(ИсходнаяСтрока, КодировкаТекста.UTF8);
    Base64Обычный = ПолучитьСтрокуИзДвоичныхДанных(ДвоичныеДанные, КодировкаТекста.Base64);
    Сообщить("Обычный Base64 (размер): " + СтрДлина(Base64Обычный));
    
    // Способ 2: сжатие + Base64
    // Используем Zip для сжатия строки
    ВременныйАрхив = Новый ZipЗапись("temp.zip");
    ВременныйАрхив.Добавить("data.txt", ИсходнаяСтрока);
    ВременныйАрхив.Записать();
    ВременныйАрхив.Закрыть();
    
    // Читаем ZIP-файл как двоичные данные
    ДвоичныеZIP = Новый ДвоичныеДанные("temp.zip");
    Base64Сжатый = ПолучитьСтрокуИзДвоичныхДанных(ДвоичныеZIP, КодировкаТекста.Base64);
    Сообщить("Сжатый + Base64 (размер): " + СтрДлина(Base64Сжатый));
    
    // Удаляем временный файл
    УдалитьФайлы("temp.zip");
    
    // Восстановление (декодирование + распаковка)
    ДвоичныеZIPИзBase64 = ПолучитьДвоичныеДанныеИзСтроки(Base64Сжатый, КодировкаТекста.Base64);
    ДвоичныеZIPИзBase64.Записать("temp_restored.zip");
    
    ЧтениеZIP = Новый ZipЧтение("temp_restored.zip");
    Для Каждого Элемент Из ЧтениеZIP.Элементы Цикл
        Если Не Элемент.ЭтоFolder Тогда
            ВосстановленнаяСтрока = ЧтениеZIP.Извлечь(Элемент);
            ЧтениеZIP.Закрыть();
            Сообщить("Восстановленная строка (первые 100 символов): " + Лев(ВосстановленнаяСтрока, 100) + "...");
            Прервать;
        КонецЕсли;
    КонецЦикла;
    
    ЧтениеZIP.Закрыть();
    УдалитьФайлы("temp_restored.zip");
    
    // Вывод статистики
    Сообщить("Статистика:");
    Сообщить("- Исходный размер: " + СтрДлина(ИсходнаяСтрока) + " символов");
    Сообщить("- Base64 без сжатия: " + СтрДлина(Base64Обычный) + " символов");
    Сообщить("- Base64 со сжатием: " + СтрДлина(Base64Сжатый) + " символов");
    Сообщить("- Экономия: " + Окр((1 - СтрДлина(Base64Сжатый) / СтрДлина(Base64Обычный)) * 100, 2) + "%");
    
КонецПроцедуры

Примечания

// Важные особенности кодирования строк Base64 в 1С:
// 1. Для работы с Base64 используются функции:
//    - ПолучитьДвоичныеДанныеИзСтроки(Строка, КодировкаТекста.Base64)
//    - ПолучитьСтрокуИзДвоичныхДанных(ДвоичныеДанные, КодировкаТекста.Base64)
// 2. Base64 увеличивает размер данных примерно на 33% по сравнению с исходными
// 3. При кодировании текста важно правильно указать исходную кодировку (UTF-8, ANSI и т.д.)
// 4. Base64 - безопасный способ передачи бинарных данных через текстовые протоколы (HTTP, JSON, XML)
// 5. При работе с файлами сначала читайте их как ДвоичныеДанные, затем кодируйте
// 6. Для декодирования обязательно используйте ту же кодировку, что и при кодировании
// 7. Base64 строки могут быть длинными - учитывайте это при выводе в интерфейс
// 8. Для уменьшения размера перед Base64 можно использовать сжатие (ZIP, GZip)
// 9. В HTTP-заголовках и JSON данные в Base64 передаются как обычные строки
// 10. При массовом кодировании используйте таблицу результатов для контроля
// 11. Base64 используется для встраивания изображений в HTML (data:image)
// 12. Всегда обрабатывайте возможные ошибки при работе с файлами и кодировании