Как проверить строку на наличие кириллицы в 1С и подготовить данные для штрихкода Code128?

При работе с номенклатурой и генерацией штрихкодов в системе 1С часто возникает проблема: артикулы или другие данные, предназначенные для печати на этикетках с использованием стандарта Code128, могут содержать кириллические символы. Важно понимать, что стандарт Code128 не поддерживает кириллицу, он предназначен для кодирования 128 символов ASCII, включающих латинские буквы, цифры и некоторые спецсимволы. Попытка закодировать кириллицу напрямую приведет к ошибкам и нечитаемым штрихкодам.

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

Ограничения Code128 и общая стратегия

Прежде чем погружаться в технические детали, давайте уясним, почему возникает данная проблема. Code128 — это линейный (одномерный) штрихкод. Он был разработан для кодирования данных в символах ASCII. Кириллица, как и многие другие нелатинские алфавиты, не входит в базовый набор ASCII. Поэтому, если в вашей строке (например, в артикуле номенклатуры) присутствует кириллица, ее нельзя напрямую передать в генератор Code128. Решения здесь могут быть следующими:

1. Запретить печать: Если в артикуле есть кириллица, просто не формировать штрихкод и информировать пользователя. Это самое простое, но не всегда удобное решение.
2. Очистить/Заменить: Удалить или заменить все кириллические символы на латинские эквиваленты или пустые строки. Однако это может привести к потере уникальности или нечитаемости артикула.
3. Транслитерация: Преобразовать кириллические символы в соответствующие латинские. Это наиболее гибкий и рекомендуемый подход, так как он сохраняет осмысленность артикула и позволяет сформировать корректный штрихкод.
4. Использовать другие стандарты штрихкодов: Если кириллица критически важна и ее нельзя транслитерировать, рассмотреть переход на двумерные штрихкоды (например, QR-код или DataMatrix), которые поддерживают символы Unicode.

В рамках данной статьи мы сосредоточимся на проверке строки и ее подготовке для Code128.

Метод 1: Проверка строки поэлементным перебором с использованием функции Найти()

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

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

   
   Функция ЕстьКириллица(ИсходнаяСтрока) Экспорт
       ЕстьКириллица = Ложь;
       // ...
   КонецФункции
   

2. Предварительная обработка строки: Перед проверкой рекомендуется очистить строку от пробелов в начале и конце, а также привести ее к одному регистру, чтобы избежать дублирования наборов символов для проверки (например, "а" и "А").
   Скопировать код

   
   Функция ЕстьКириллица(ИсходнаяСтрока) Экспорт
       ЕстьКириллица = Ложь;
       ИсходнаяСтрока = СокрЛП(ИсходнаяСтрока); // Удаляем лишние пробелы
       Если СтрДлина(ИсходнаяСтрока) > 0 Тогда
           // ...
       КонецЕсли;
       Возврат ЕстьКириллица;
   КонецФункции
   

3. Перебор символов: Используем цикл для прохода по каждому символу в строке.
   Скопировать код

   
   Функция ЕстьКириллица(ИсходнаяСтрока) Экспорт
       ЕстьКириллица = Ложь;
       ИсходнаяСтрока = СокрЛП(ИсходнаяСтрока);
       Если СтрДлина(ИсходнаяСтрока) > 0 Тогда
           Для Сч = 1 По СтрДлина(ИсходнаяСтрока) Цикл
               Символ = НРег(Сред(ИсходнаяСтрока, Сч, 1)); // Приводим символ к нижнему регистру
               // ...
           КонецЦикла;
       КонецЕсли;
       Возврат ЕстьКириллица;
   КонецФункции
   

4. Проверка символа: Внутри цикла проверяем, входит ли текущий символ в строку, содержащую все кириллические буквы. Для этого используем функцию Найти().
   Скопировать код

   
   Функция ЕстьКириллица(ИсходнаяСтрока) Экспорт
       ЕстьКириллица = Ложь;
       ИсходнаяСтрока = СокрЛП(ИсходнаяСтрока);
       Если СтрДлина(ИсходнаяСтрока) > 0 Тогда
           Для Сч = 1 По СтрДлина(ИсходнаяСтрока) Цикл
               Символ = НРег(Сред(ИсходнаяСтрока, Сч, 1));
               Если Найти("абвгдеёжзийклмнопрстуфхцчшщъыьэюя", Символ) Тогда
                   ЕстьКириллица = Истина;
                   // ...
               КонецЕсли;
           КонецЦикла;
       КонецЕсли;
       Возврат ЕстьКириллица;
   КонецФункции
   

   Обратите внимание, что мы используем строку с кириллическими буквами в нижнем регистре, так как ранее мы привели проверяемый символ к нижнему регистру с помощью НРег().

5. Оптимизация – немедленный возврат: Если кириллический символ найден, нет необходимости продолжать проверку оставшейся части строки. Мы можем сразу же вернуть Истина. Это значительно повышает производительность функции для длинных строк, где кириллица встречается в начале.
   Скопировать код

   
   Функция ЕстьКириллица(ИсходнаяСтрока) Экспорт
       ИсходнаяСтрока = СокрЛП(ИсходнаяСтрока);
       Если СтрДлина(ИсходнаяСтрока) > 0 Тогда
           Для Сч = 1 По СтрДлина(ИсходнаяСтрока) Цикл
               Символ = НРег(Сред(ИсходнаяСтрока, Сч, 1));
               Если Найти("абвгдеёжзийклмнопрстуфхцчшщъыьэюя", Символ) Тогда
                   Возврат Истина; // Найден кириллический символ, сразу возвращаем Истина
               КонецЕсли;
           КонецЦикла;
       КонецЕсли;
       Возврат Ложь; // Если цикл завершился, значит, кириллицы нет
   КонецФункции
   

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

Метод 2: Проверка по кодам символов Unicode

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

1. Функция КодСимвола(): Платформа 1С предоставляет функцию КодСимвола(), которая возвращает код Unicode для заданного символа.
   Скопировать код

   
   Функция ЕстьКириллицаПоКоду(ИсходнаяСтрока) Экспорт
       ИсходнаяСтрока = СокрЛП(ИсходнаяСтрока);
       Если СтрДлина(ИсходнаяСтрока) = 0 Тогда
           Возврат Ложь;
       КонецЕсли;
   
       Для Сч = 1 По СтрДлина(ИсходнаяСтрока) Цикл
           Код = КодСимвола(ИсходнаяСтрока, Сч);
           // ...
       КонецЦикла;
       Возврат Ложь;
   КонецФункции
   

2. Диапазоны Unicode для кириллицы: Основные кириллические символы находятся в диапазонах Unicode:
   • U+0400 – U+04FF (от 1024 до 1279 в десятичной системе) – содержит большинство русских, украинских, белорусских и других кириллических букв, включая "Ё" (U+0401, U+0451).
   • Дополнительные диапазоны: U+0500 – U+052F, U+2DE0 – U+2DFF, U+A640 – U+A69F могут содержать расширенные кириллические символы, используемые в редких языках или исторических текстах. Для большинства практических задач достаточно первого диапазона.

   Используя эти диапазоны, мы можем проверить, попадает ли код символа в кириллическую область.

3. Реализация проверки на кириллицу:
   Скопировать код

   
   Функция ЕстьКириллицаПоКоду(ИсходнаяСтрока) Экспорт
       ИсходнаяСтрока = СокрЛП(ИсходнаяСтрока);
       Если СтрДлина(ИсходнаяСтрока) = 0 Тогда
           Возврат Ложь;
       КонецЕсли;
   
       Для Сч = 1 По СтрДлина(ИсходнаяСтрока) Цикл
           Код = КодСимвола(ИсходнаяСтрока, Сч);
           // Проверяем, находится ли код символа в диапазоне основной кириллицы
           Если (Код >= 1024 И Код <= 1279) Тогда // U+0400 - U+04FF
               Возврат Истина;
           КонецЕсли;
       КонецЦикла;
       Возврат Ложь;
   КонецФункции
   

4. Расширенная проверка на допустимые символы (для Code128): Вместо того чтобы искать только кириллицу, мы можем проверять, содержит ли строка любые символы, кроме разрешенных (латиница, цифры, некоторые спецсимволы). Это более правильный подход для Code128.
   Скопировать код

   
   Функция СодержитНедопустимыеСимволыДляCode128(ИсходнаяСтрока) Экспорт
       ИсходнаяСтрока = СокрЛП(ИсходнаяСтрока);
       Если СтрДлина(ИсходнаяСтрока) = 0 Тогда
           Возврат Ложь; // Пустая строка считается допустимой
       КонецЕсли;
   
       Для Сч = 1 По СтрДлина(ИсходнаяСтрока) Цикл
           Код = КодСимвола(ИсходнаяСтрока, Сч);
           // Разрешенные символы ASCII для Code128 (цифры, латинские буквы, спецсимволы).
           // Диапазоны для ASCII: 32-126 (печатаемые символы), + некоторые управляющие.
           // Для простоты, часто проверяют на буквы (A-Z, a-z), цифры (0-9) и основные спецсимволы.
   
           // Диапазон цифр 0-9
           Если (Код >= 48 И Код <= 57) Тогда
               Продолжить;
           КонецЕсли;
           // Диапазон заглавных латинских букв A-Z
           Если (Код >= 65 И Код <= 90) Тогда
               Продолжить;
           КонецЕсли;
           // Диапазон строчных латинских букв a-z
           Если (Код >= 97 И Код <= 122) Тогда
               Продолжить;
           КонецЕсли;
           // Основные спецсимволы и пробел (пример: Space, !, ", #, $, %, &, ', (, ), *, +, ,, -, ., /)
           // Эти диапазоны могут быть расширены в зависимости от конкретных требований к Code128
           Если (Код >= 32 И Код <= 47) Тогда
               Продолжить;
           КонецЕсли;
           Если (Код >= 58 И Код <= 64) Тогда // : ; < = > ? @
               Продолжить;
           КонецЕсли;
           Если (Код >= 91 И Код <= 96) Тогда // [ \ ] ^ _ `
               Продолжить;
           КонецЕсли;
           If (Код >= 123 И Код <= 126) Тогда // { | } ~
               Продолжить;
           КонецЕсли;
   
           // Если символ не попал ни в один из разрешенных диапазонов, значит, он недопустим
           Возврат Истина;
       КонецЦикла;
   
       Возврат Ложь; // Все символы в строке допустимы для Code128
   КонецФункции
   

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

   Скопировать код

   
   Функция ПроверкаНаСимволыКромеЦифр(СтрокаПроверки) Экспорт
       СтрокаПроверки = СокрЛП(СтрокаПроверки);
       Если СтрДлина(СтрокаПроверки) = 0 Тогда
           Возврат Ложь; // Пустая строка не содержит недопустимых символов, если требуется только цифры
       КонецЕсли;
       
       Для а = 1 По СтрДлина(СтрокаПроверки) Цикл
           КодСимвола = КодСимвола(Сред(СтрокаПроверки, а, 1));
           Если Не (КодСимвола >= 48 И КодСимвола <= 57) Тогда // 48 - код '0', 57 - код '9'
               Возврат Истина; // Найден символ, который не является цифрой
           КонецЕсли;
       КонецЦикла;
       Возврат Ложь; // Все символы - цифры
   КонецФункции
   

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

Метод 3: Использование встроенных функций конфигурации

Прежде чем писать собственный код, всегда проверяйте типовые конфигурации 1С. Очень часто разработчики уже предусмотрели общие функции для таких задач. Например, во многих конфигурациях (УПП, ERP, КА, УТ) существует общий модуль СтроковыеФункцииКлиентСервер (или аналогичный), который содержит полезные функции для работы со строками.

Одной из таких функций является СтроковыеФункцииКлиентСервер.ТолькоЛатиницаВСтроке() (или похожая), которая может принимать строку и возвращать ее версию, содержащую только латинские символы и, возможно, заданные дополнительные символы (например, цифры). Это идеальное решение, если вы хотите не только проверить, но и очистить строку от недопустимых символов или оставить только латиницу и цифры.

Пример использования (синтаксис может немного отличаться в разных версиях/конфигурациях):

Перем Результат;
СтрокаДляШтрихкода = "Артикул123ABCD";
СтроковыеФункцииКлиентСервер.ТолькоЛатиницаВСтроке(СтрокаДляШтрихкода, Результат, "0123456789");
// Теперь в переменной Результат будет строка, содержащая только латинские буквы и цифры.
// Например, если СтрокаДляШтрихкода = "Артикул123ABCD", то Результат = "тикул123ABCD" (если функция только удаляет, а не транслитерирует).
// Или, если функция умная и умеет, то "Artikul123ABCD".
// Важно прочитать описание функции в вашей конфигурации!

// Для проверки наличия кириллицы, вы можете сравнить исходную строку с результатом:
Если НРег(СокрЛП(Артикул)) <> НРег(СокрЛП(СтрокаДляШтрихкода)) Тогда
    Сообщить("Артикул содержит недопустимые символы!");
КонецЕсли;

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

Метод 4: Транслитерация – рекомендуемый подход

Вместо того чтобы просто запрещать печать или удалять символы, наиболее функциональным решением является транслитерация кириллических символов в их латинские аналоги. Это позволяет сохранить читаемость и уникальность артикула, а также генерировать корректные штрихкоды Code128. Транслитерация — это не просто удаление, а преобразование "А" в "A", "Б" в "B", "Ч" в "CH" и так далее.

1. Создание функции транслитерации: Мы можем создать функцию, которая будет заменять каждый кириллический символ на его латинский эквивалент с использованием множественных вызовов СтрЗаменить().
   Скопировать код

   
   Функция Транслит(Имя) Экспорт
       Рез = СокрЛП(Имя);
   
       // Замена строчных кириллических букв
       Рез = СтрЗаменить(Рез,"а","a");
       Рез = СтрЗаменить(Рез,"б","b");
       Рез = СтрЗаменить(Рез,"в","v");
       Рез = СтрЗаменить(Рез,"г","g");
       Рез = СтрЗаменить(Рез,"д","d");
       Рез = СтрЗаменить(Рез,"е","e");
       Рез = СтрЗаменить(Рез,"ё","e");
       Рез = СтрЗаменить(Рез,"ж","zh");
       Рез = СтрЗаменить(Рез,"з","z");
       Рез = СтрЗаменить(Рез,"и","i");
       Рез = СтрЗаменить(Рез,"й","i");
       Рез = СтрЗаменить(Рез,"к","k");
       Рез = СтрЗаменить(Рез,"л","l");
       Рез = СтрЗаменить(Рез,"м","m");
       Рез = СтрЗаменить(Рез,"н","n");
       Рез = СтрЗаменить(Рез,"о","o");
       Рез = СтрЗаменить(Рез,"п","p");
       Рез = СтрЗаменить(Рез,"р","r");
       Рез = СтрЗаменить(Рез,"с","s");
       Рез = СтрЗаменить(Рез,"т","t");
       Рез = СтрЗаменить(Рез,"у","u");
       Рез = СтрЗаменить(Рез,"ф","f");
       Рез = СтрЗаменить(Рез,"х","h");
       Рез = СтрЗаменить(Рез,"ц","c");
       Рез = СтрЗаменить(Рез,"ч","ch");
       Рез = СтрЗаменить(Рез,"ш","sh");
       Рез = СтрЗаменить(Рез,"щ","sch");
       Рез = СтрЗаменить(Рез,"ъ",""); // Твердый знак обычно удаляется
       Рез = СтрЗаменить(Рез,"ы","i");
       Рез = СтрЗаменить(Рез,"ь",""); // Мягкий знак обычно удаляется
       Рез = СтрЗаменить(Рез,"э","e");
       Рез = СтрЗаменить(Рез,"ю","yu");
       Рез = СтрЗаменить(Рез,"я","ya");
   
       // Замена заглавных кириллических букв
       Рез = СтрЗаменить(Рез,"А","A");
       Рез = СтрЗаменить(Рез,"Б","B");
       Рез = СтрЗаменить(Рез,"В","V");
       Рез = СтрЗаменить(Рез,"Г","G");
       Рез = СтрЗаменить(Рез,"Д","D");
       Рез = СтрЗаменить(Рез,"Е","E");
       Рез = СтрЗаменить(Рез,"Ё","E");
       Рез = СтрЗаменить(Рез,"Ж","ZH");
       Рез = СтрЗаменить(Рез,"З","Z");
       Рез = СтрЗаменить(Рез,"И","I");
       Рез = СтрЗаменить(Рез,"Й","I");
       Рез = СтрЗаменить(Рез,"К","K");
       Рез = СтрЗаменить(Рез,"Л","L");
       Рез = СтрЗаменить(Рез,"М","M");
       Рез = СтрЗаменить(Рез,"Н","N");
       Рез = СтрЗаменить(Рез,"О","O");
       Рез = СтрЗаменить(Рез,"П","P");
       Рез = СтрЗаменить(Рез,"Р","R");
       Рез = СтрЗаменить(Рез,"С","S");
       Рез = СтрЗаменить(Рез,"Т","T");
       Рез = СтрЗаменить(Рез,"У","U");
       Рез = СтрЗаменить(Рез,"Ф","F");
       Рез = СтрЗаменить(Рез,"Х","H");
       Рез = СтрЗаменить(Рез,"Ц","C");
       Рез = СтрЗаменить(Рез,"Ч","CH");
       Рез = СтрЗаменить(Рез,"Ш","SH");
       Рез = СтрЗаменить(Рез,"Щ","SCH");
       Рез = СтрЗаменить(Рез,"Ъ","");
       Рез = СтрЗаменить(Рез,"Ы","I");
       Рез = СтрЗаменить(Рез,"Ь","");
       Рез = СтрЗаменить(Рез,"Э","E");
       Рез = СтрЗаменить(Рез,"Ю","YU");
       Рез = СтрЗаменить(Рез,"Я","YA");
   
       Возврат Рез;
   КонецФункции
   

   Показать весь код
2. Стандарты транслитерации: При реализации транслитерации желательно придерживаться существующих стандартов (например, ГОСТ 7.79-2000 или ISO 9). Это обеспечит единообразие и предсказуемость преобразования. Хотя приведенный выше пример является базовым, для сложных случаев или интернациональных проектов можно найти более полные таблицы соответствий.

Преимущества транслитерации:

• Сохранение уникальности артикула (в большинстве случаев), что критически важно для штрихкодов.
• Читаемость данных для человека, так как транслитерированный артикул похож на оригинал.
• Подготовка данных к формату, совместимому с Code128.

Метод 5: Использование оператора ПОДОБНО в запросах 1С

Для проверки строки на наличие определенных символов, особенно если вы работаете с данными непосредственно в базе данных (например, в запросе СКД или при обработке большого объема записей), можно использовать оператор ПОДОБНО в языке запросов 1С. Этот метод позволяет искать символы, не входящие в определенный набор. Однако для проверки одной строки в коде 1С он может быть менее производительным из-за накладных расходов на выполнение запроса.

Давайте рассмотрим пример, как проверить, содержит ли строка только цифры:

1. Создание запроса: Мы сформируем запрос, который использует регулярное выражение в операторе ПОДОБНО. Шаблон "%[^0-9]%" означает "любая строка, содержащая хотя бы один символ, который НЕ является цифрой от 0 до 9".
   Скопировать код

   
   Функция ТолькоЦифрыВСтрокеЗапросом(СН) Экспорт
       Запрос = Новый Запрос;
       Запрос.Текст = "ВЫБРАТЬ ИСТИНА КАК ЕстьНеЦифры
                     |ИЗ DUMMY КАК Заглушка
                     |ГДЕ &СН ПОДОБНО ""%[^0-9]%"""; // Проверяем, есть ли хоть один НЕ-цифровой символ
   
       Запрос.УстановитьПараметр("СН", СН);
       РезультатЗапроса = Запрос.Выполнить();
       // Если выборка пуста, значит, строка НЕ содержит нецифровых символов, т.е. состоит ТОЛЬКО из цифр
       Возврат РезультатЗапроса.Пустой; 
   КонецФункции
   

2. Использование функции:
   Скопировать код

   
   АртикулТест = "123456";
   Если ТолькоЦифрыВСтрокеЗапросом(АртикулТест) Тогда
       Сообщить("Артикул '" + АртикулТест + "' состоит только из цифр.");
   Иначе
       Сообщить("Артикул '" + АртикулТест + "' содержит нецифровые символы.");
   КонецЕсли;
   
   АртикулТест = "123АВС456";
   Если ТолькоЦифрыВСтрокеЗапросом(АртикулТест) Тогда
       Сообщить("Артикул '" + АртикулТест + "' состоит только из цифр.");
   Иначе
       Сообщить("Артикул '" + АртикулТест + "' содержит нецифровые символы.");
   КонецЕсли;
   

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

Метод 6: Проверка с использованием функций СтрРазделить() и СтрСоединить()

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

Однако есть нюанс: СтрРазделить() удаляет разделители. Если мы разделим строку по кириллическим символам, а затем соединим оставшиеся части, мы получим строку без кириллицы. Если эта строка окажется короче исходной, значит, кириллица была.

Давайте рассмотрим этот метод:

Функция ЕстьКириллицаЧерезРазделитьСоединить(ИсходнаяСтрока) Экспорт
    ИсходнаяСтрокаВНижнемРегистре = НРег(ИсходнаяСтрока);
    
    // Строка-разделитель, содержащая все кириллические символы
    СтрокаКириллицы = "абвгдеёжзийклмнопрстуфхцчшщъыьэюя";

    // Разделяем исходную строку по каждому кириллическому символу.
    // Если кириллица есть, массив будет содержать части без этих символов.
    МассивЧастей = СтрРазделить(ИсходнаяСтрокаВНижнемРегистре, СтрокаКириллицы);
    
    // Соединяем все части обратно. Получаем строку, из которой "вырезана" кириллица.
    СтрокаБезКириллицы = СтрСоединить(МассивЧастей);
    
    // Если длина строки без кириллицы меньше длины исходной строки, значит, кириллица была.
    Возврат СтрДлина(СтрокаБезКириллицы) < СтрДлина(ИсходнаяСтрокаВНижнемРегистре);
КонецФункции

// Пример использования
Если ЕстьКириллицаЧерезРазделитьСоединить("Привет Мир") Тогда
    Сообщить("Строка содержит кириллицу.");
Иначе
    Сообщить("Строка не содержит кириллицу.");
КонецЕсли;

Если ЕстьКириллицаЧерезРазделитьСоединить("Hello World") Тогда
    Сообщить("Строка содержит кириллицу.");
Иначе
    Сообщить("Строка не содержит кириллицу.");
КонецЕсли;

Преимущество: Это довольно компактное решение. Недостаток: Может быть менее интуитивным для нонимающих принцип работы СтрРазделить() с несколькими разделителями. Также для очень длинных строк и большого количества кириллических символов может быть не самым производительным из-за создания временного массива и нескольких операций со строками.

Вариант "от обратного" с использованием СтрРазделить для проверки на допустимые символы:

Функция ЭтоКорректнаяСтрока(ИсходнаяСтрока) Экспорт
    // Допустимые символы для Code128 (латиница, цифры, пробел)
    ДопустимыеСимволы = "abcdefghijklmnopqrstuvwxyz0123456789 ";
    ИсходнаяСтрокаВНижнемРегистре = НРег(ИсходнаяСтрока);
    
    // Разделяем строку по всем допустимым символам.
    // Если в исходной строке останутся какие-то символы, которые НЕ являются допустимыми,
    // то СтрРазделить вернет массив, где будут пустые строки или сами эти недопустимые символы,
    // а их количество будет > 0.
    // В данном случае, если все символы допустимы, СтрРазделить вернет массив с одним пустым элементом, 
    // если исходная строка непустая и содержит только допустимые символы.
    // Если исходная строка пустая, вернется массив с одним пустым элементом.
    // Если исходная строка содержит недопустимый символ, например "А", то при разделении
    // по "a-z0-9 " этот "А" останется элементом массива.

    // Корректнее использовать подход, когда количество частей после разделения
    // по "разрешенным" символам должно быть 1, если нет "запрещенных" символов
    // ИЛИ, наоборот, если разделить по НЕдопустимым символам, и массив будет размером 1, то их не было.
    // Давайте лучше пойдём по пути поиска недопустимых символов.

    // Предполагаем, что корректная строка - это та, которая не содержит "запрещенных" символов
    // В Code128 запрещены все, кроме определенного набора ASCII.
    // Здесь мы проверяем, что строка состоит ИСКЛЮЧИТЕЛЬНО из перечисленных допустимых символов.
    // СтрРазделить(Строка, НаборРазделителей, Ложь) возвращает массив строк,
    // где каждый элемент - это подстрока, которая НЕ ЯВЛЯЕТСЯ разделителем.
    // Если исходная строка состоит ТОЛЬКО из разделителей, то массив будет состоять из пустых строк.
    // Если исходная строка = "abc", а разделители "ab", то массив будет ["c"].
    // Если исходная строка = "abc", а разделители "abc", то массив будет ["","","",""].
    // Если исходная строка = "a!b", а разделители "ab", то массив будет ["","!",""].
    // Т.е. нам нужно, чтобы в полученном массиве не было НИ ОДНОЙ непустой строки.
    // Более простой способ: разделить по ВСЕМУ ЧТО НЕ ЯВЛЯЕТСЯ РАЗДЕЛИТЕЛЕМ.
    // Если получим пустой массив или массив из пустых строк, значит, все символы были разделителями.

    // Упрощенный вариант, проверяющий, что строка содержит только латиницу, цифры и пробел.
    // СтрРазделить возвращает массив частей, которые находятся МЕЖДУ разделителями.
    // Если строка "А12Б" и разделители "12", массив будет ["А", "Б"]. Количество = 2.
    // Если строка "123" и разделители "123", массив будет ["", "", "", ""]. Количество = 4.
    // Если строка "АБВ" и разделители "123", массив будет ["АБВ"]. Количество = 1.
    // Этот метод не очень надежен для определения "только допустимых".

    // Лучше вернемся к методу перебора кодов символов, как в Методе 2.
    // Или используем СтрЗаменить.
    
    // Однако, можно попробовать интерпретацию из форума:
    // Разделить по "допустимым" символам, и если в результирующем массиве 
    // останется более одного элемента (или он не будет состоять только из пустых строк),
    // то значит были недопустимые символы.

    // Корректная реализация идеи из сообщения 32, которая ищет наличие недопустимых символов:
    ДопустимыеСимволы = "abcdefghijklmnopqrstuvwxyz0123456789 ";
    ИсходнаяСтрокаНижнийРегистр = НРег(ИсходнаяСтрока);

    // Удаляем все допустимые символы из строки.
    // Если после этого строка осталась непустой, значит, в ней были недопустимые символы.
    СтрокаБезДопустимых = ИсходнаяСтрокаНижнийРегистр;
    Для Сч = 1 По СтрДлина(ДопустимыеСимволы) Цикл
        Символ = Сред(ДопустимыеСимволы, Сч, 1);
        СтрокаБезДопустимых = СтрЗаменить(СтрокаБезДопустимых, Символ, "");
    КонецЦикла;

    // Если остаток строки не пуст, значит были символы, не входящие в ДопустимыеСимволы.
    Возврат СтрДлина(СтрокаБезДопустимых) = 0;
КонецФункции

// Пример использования
Если ЭтоКорректнаяСтрока("ARTIKUL123") Тогда
    Сообщить("Строка корректна для Code128.");
Иначе
    Сообщить("Строка содержит недопустимые символы для Code128.");
КонецЕсли;

Если ЭтоКорректнаяСтрока("Артикул123") Тогда
    Сообщить("Строка корректна для Code128.");
Иначе
    Сообщить("Строка содержит недопустимые символы для Code128.");
КонецЕсли;

Этот вариант ЭтоКорректнаяСтрока фактически является расширенным применением СтрЗаменить, проверяя строку на отсутствие любых символов, кроме заданного "белого списка".

Метод 7: Использование регулярных выражений (продвинутый подход)

Для более сложных и гибких проверок, особенно в современных версиях 1С (начиная с 8.3.5), можно использовать регулярные выражения через объект COMОбъект("VBScript.RegExp"). Это мощный инструмент для поиска и анализа строк.

1. Создание объекта RegExp:
   Скопировать код

   
   Функция ЕстьКириллицаРегВыражение(ИсходнаяСтрока) Экспорт
       Попытка
           RegExp = Новый COMОбъект("VBScript.RegExp");
       Исключение
           Сообщить("Ошибка инициализации RegExp: " + ОписаниеОшибки());
           Возврат Ложь;
       КонецПопытки;
   
       RegExp.Global = Истина; // Искать все вхождения, не только первое
       RegExp.IgnoreCase = Истина; // Игнорировать регистр (А и а)
       RegExp.Pattern = "[а-яё]"; // Шаблон для поиска кириллических букв (в нижнем регистре)
   
       Возврат RegExp.Test(ИсходнаяСтрока); // Возвращает Истина, если найдено хотя бы одно совпадение
   КонецФункции
   
   // Пример использования
   Если ЕстьКириллицаРегВыражение("Пример строки с кириллицей") Тогда
       Сообщить("Строка содержит кириллицу.");
   Иначе
       Сообщить("Строка не содержит кириллицу.");
   КонецЕсли;
   
   Если ЕстьКириллицаРегВыражение("Example string with Latin") Тогда
       Сообщить("Строка содержит кириллицу.");
   Иначе
       Сообщить("Строка не содержит кириллицу.");
   КонецЕсли;
   

2. Шаблоны регулярных выражений:
   • "[а-яёА-ЯЁ]": Ищет любую русскую кириллическую букву (строчную или заглавную). Если используете IgnoreCase = Истина, достаточно "[а-яё]".
   • "[^a-zA-Z0-9\s\p{P}]": Ищет любой символ, который НЕ является латинской буквой, цифрой, пробелом или знаками препинания. Это хороший шаблон для поиска "недопустимых" символов в целом. \s - пробельные символы, \p{P} - знаки препинания (для VBScript.RegExp может потребоваться перечисление конкретных знаков препинания).

Преимущества регулярных выражений:

• Гибкость: Можно создавать очень сложные и точные шаблоны для поиска любых комбинаций символов.
• Краткость: Проверка сводится к нескольким строкам кода.
• Производительность: Для сложных проверок и больших объемов данных регулярные выражения, реализованные на уровне COM-объекта, могут быть быстрее, чем чисто 1С-овский перебор.

Недостатки: Зависимость от COM-объекта может вызвать проблемы на некоторых клиентских машинах или в веб-клиенте (хотя на сервере 1С обычно работает стабильно). Также требует знания синтаксиса регулярных выражений.

Заключение и рекомендации

Мы рассмотрели множество способов проверки строк на наличие кириллицы в 1С и подготовки данных для штрихкодов Code128. Давайте суммируем рекомендации:

1. Прежде всего: Всегда проверяйте наличие готовых функций в общих модулях вашей конфигурации (например, при разработке внешних печатных форм на БСП). Это самый быстрый и надежный путь, так как эти функции уже протестированы и оптимизированы разработчиками 1С.
2. Оптимальная проверка на наличие кириллицы: Если готовой функции нет, используйте функцию с поэлементным перебором символов и немедленным возвратом Истина при нахождении первого кириллического символа (см. Метод 1, оптимизированный вариант). Это эффективно и понятно.
3. Универсальное решение для Code128: Для формирования штрихкодов Code128 транслитерация является наиболее правильным и универсальным подходом (см. Метод 4). Она позволяет сохранить информативность артикула и избежать потери уникальности. После транслитерации следует дополнительно убедиться, что полученная строка содержит только допустимые для Code128 символы (латиница, цифры, спецсимволы ASCII).
4. Проверка на допустимые символы Code128: Используйте метод перебора по кодам символов (Метод 2) для создания функции, которая проверяет, что все символы в строке находятся в разрешенном диапазоне ASCII для Code128.
5. Продвинутые сценарии: Для сложных проверок или массовой обработки данных в базе, рассмотрите использование регулярных выражений (Метод 7) или оператора ПОДОБНО в запросах (Метод 5), но учтите их особенности и возможные накладные расходы.
6. Альтернативы: Если транслитерация недопустима или недостаточна, рассмотрите использование двумерных штрихкодов (QR-код, DataMatrix), которые полностью поддерживают Unicode и, соответственно, кириллицу.

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