На управляемой форме 1С:Предприятие часто возникает задача обеспечить чистоту вводимых данных. Одним из распространенных сценариев является необходимость обрезать лишние пробелы (справа, слева или даже внутри) при вставке текста из буфера обмена в поле ввода. Это критически важно для корректной работы поиска, фильтрации и обеспечения целостности данных, поскольку строка "1234567890" и "123 456789" с точки зрения системы являются совершенно разными значениями.
Давайте разберем, как можно реализовать такую функционацию, учитывая различные версии платформы 1С и доступные механизмы.
Прежде чем перейти к решениям, выясним, почему стандартные события поля ввода, такие как ПриИзменении и ИзменениеТекстаРедактирования, не подходят для решения нашей задачи "до вставки".
ПриИзменении: Это событие возникает уже после того, как значение поля ввода изменилось и пользователь перешел на другой элемент управления или явным образом подтвердил ввод (например, нажал Enter). Нам же требуется обработать строку до ее фактического сохранения в значении поля, чтобы пользователь сразу видел "чистый" результат.ИзменениеТекстаРедактирования: Это событие отрабатывает, когда текст в поле ввода изменяется, в том числе и после вставки из буфера обмена. Однако на момент его срабатывания в поле уже может находиться строка с пробелами, и пользователь увидит эту "грязную" строку. Цель же — предотвратить ее появление вообще.Таким образом, для обработки текста именно "до вставки" или сразу после, но с мгновенным визуальным обновлением, требуются более специфичные подходы.
Методы работы с буфером обмена и обработки ввода значительно различаются в зависимости от версии платформы.
В относительно новых версиях платформы 1С:Предприятие, начиная с 8.3.24, появились встроенные средства для программной работы с буфером обмена через объект СредстваБуфераОбмена. Это открывает новые горизонты, хотя и имеет свои нюансы.
Объект СредстваБуфераОбмена предоставляет методы для работы с буфером обмена. Например, мы можем получить текст из буфера с помощью СредстваБуфераОбмена.ПолучитьТекст(). Однако, важно отметить, что новое клиентское событие ПриВставкеИзБуфераОбмена(), доступное для управляемых форм и глобального модуля приложения, срабатывает преимущественно при вставке из буфера картинок или файлов, а не обычного текста. Это означает, что для текстовых данных нам, вероятно, придется использовать универсальные подходы постобработки, но уже с использованием нативных средств для чтения и модификации буфера, если это требуется, или, что чаще, работать со значением поля после вставки.
В случае, если мы хотим перехватить текст из буфера обмена и обработать его перед тем, как он попадет в поле ввода (т.е. реализовать "предварительную" очистку), прямой механизм через событие ПриВставкеИзБуфераОбмена() для текста не всегда подойдет. Более реалистичный сценарий с новыми средствами — это чтение буфера в событии, которое происходит сразу после (например, ПриИзменении или ПриОкончанииРедактирования), очистка текста и затем присвоение очищенного значения полю ввода.
Пример использования СредстваБуфераОбмена (для постобработки):
&НаКлиенте
Процедура ПолеВводаПриИзменении(Элемент)
// Получаем текущее значение поля ввода
ИсходнаяСтрока = Элемент.Значение;
// Проверяем, есть ли текст в буфере обмена
// (Это косвенный способ определить, что что-то могло быть вставлено,
// но не гарантирует, что это именно то, что вставлено в поле)
ТекстИзБуфера = СредстваБуфераОбмена.ПолучитьТекст();
// Если поле ввода изменилось и есть текст в буфере (или просто хотим очистить текущее значение)
Если СтрДлина(ИсходнаяСтрока) > 0 Тогда
ОчищеннаяСтрока = СтрЗаменить(ИсходнаяСтрока, " ", ""); // Удаляем все пробелы
ОчищеннаяСтрока = Лев(ОчищеннаяСтрока, 10); // Обрезаем до 10 символов
Если ОчищеннаяСтрока <> ИсходнаяСтрока Тогда
Элемент.Значение = ОчищеннаяСтрока;
// Уведомляем пользователя о произведенной очистке
ПоказатьОповещениеПользователя(, "Текст очищен от пробелов и обрезан.", , , Ложь);
КонецЕсли;
КонецЕсли;
КонецПроцедуры
В этом примере мы очищаем уже вставленный текст. Если бы ПриВставкеИзБуфераОбмена() срабатывало для текста, можно было бы сделать более элегантное решение, обработав текст *до* его присвоения полю.
В более ранних версиях 1С, когда отсутствовали встроенные средства работы с буфером обмена, разработчики прибегали к различным "костыльным" решениям. Эти методы использовали возможности интеграции с внешними объектами.
ПолеHTMLДокумента: Мы могли разместить на форме невидимый или скрытый элемент ПолеHTMLДокумента. Через объектную модель HTML-документа можно получить доступ к буферу обмена браузера или операционной системы, так как ПолеHTMLДокумента по сути является встроенным браузером.
&НаКлиенте
Перем ОбъектHTMLДокумента;
Процедура ПриСозданииНаСервере(Отказ, СтандартнаяОбработка)
// Добавляем ПолеHTMLДокумента на форму динамически или статически в конфигураторе
// и настраиваем его
КонецПроцедуры
&НаКлиенте
Процедура ПолеВводаПриАктивизации(Элемент)
// Этот метод срабатывает при получении фокуса полем ввода.
// Здесь мы пытаемся прочитать буфер обмена ДО того, как пользователь вставит что-либо.
// Это "костыль", так как мы заранее обрабатываем буфер.
Если ОбъектHTMLДокумента = Неопределено Тогда
// Получаем доступ к ПолеHTMLДокумента, например, через ЭлементыФормы
ОбъектHTMLДокумента = Элементы.ПолеHTMLДокумента.Документ;
КонецЕсли;
Попытка
Если ОбъектHTMLДокумента <> Неопределено Тогда
// Получаем данные из буфера обмена как текст
ТекстИзБуфера = ОбъектHTMLДокумента.parentWindow.clipboardData.getData("text");
Если ЗначениеЗаполнено(ТекстИзБуфера) Тогда
// Удаляем пробелы
ОчищенныйТекст = СтрЗаменить(ТекстИзБуфера, " ", "");
ОчищенныйТекст = СокрЛП(ОчищенныйТекст); // На всякий случай
// Записываем очищенный текст обратно в буфер обмена
ОбъектHTMLДокумента.parentWindow.clipboardData.setData("text", ОчищенныйТекст);
ПоказатьОповещениеПользователя(, "Буфер обмена очищен от пробелов перед вставкой.", , , Ложь);
КонецЕсли;
КонецЕсли;
Исключение
Сообщить("Ошибка при работе с буфером обмена через ПолеHTMLДокумента: " + ОписаниеОшибки());
КонецПопытки;
КонецПроцедуры
Этот подход достаточно инвазивен, требует понимания DOM и может быть нестабилен в разных браузерных окружениях (если форма работает в веб-клиенте) или при изменениях в платформе.
COMОбъект("htmlfile"): Еще один способ, похожий на предыдущий, но без необходимости размещения элемента на форме. Мы создаем временный COM-объект типа "htmlfile" и используем его для доступа к буферу обмена.
&НаКлиенте
Процедура ПолеВводаПриАктивизации(Элемент)
Попытка
// Создаем временный объект для работы с буфером обмена
HTMLФайл = Новый COMОбъект("htmlfile");
БуферОбмена = HTMLФайл.parentWindow.clipboardData;
ТекстИзБуфера = БуферОбмена.getData("text");
Если ЗначениеЗаполнено(ТекстИзБуфера) Тогда
ОчищенныйТекст = СтрЗаменить(ТекстИзБуфера, " ", "");
ОчищенныйТекст = СокрЛП(ОчищенныйТекст);
БуферОбмена.setData("text", ОчищенныйТекст);
ПоказатьОповещениеПользователя(, "Буфер обмена очищен от пробелов.", , , Ложь);
КонецЕсли;
Исключение
Сообщить("Ошибка при работе с буфером обмена через COMОбъект: " + ОписаниеОшибки());
КонецПопытки;
КонецПроцедуры
Этот метод также имеет свои ограничения, связанные с политиками безопасности ОС и браузера, и не всегда работает надежно или без предупреждений для пользователя.
Все эти "костыльные" подходы характеризуются определенной степенью сложности внедрения, потенциальными проблемами совместимости и зависимостью от внешних факторов. Поэтому, если есть возможность, всегда предпочтительнее использовать нативные средства платформы или универсальные подходы, описанные ниже.
Если нам не удается перехватить данные до их попадания в поле ввода, или же "костыльные" решения не подходят, мы всегда можем обрабатывать строку уже после вставки, но до того, как она будет использована для поиска или сохранена в базу данных. Эти подходы являются наиболее надежными и рекомендуемыми в большинстве случаев.
Несмотря на то, что эти события срабатывают после вставки, мы можем оперативно очистить значение поля и присвоить его обратно, тем самым предоставляя пользователю мгновенную обратную связь.
ПриИзменении: Срабатывает каждый раз при изменении значения в поле ввода. Если текст вставляется из буфера обмена, это событие сработает один раз после вставки.
&НаКлиенте
Процедура ПолеВводаПриИзменении(Элемент)
// Получаем текущее значение поля ввода
ИсходнаяСтрока = Элемент.Значение;
// Проверяем, что строка не пустая и содержит пробелы, которые нужно удалить
Если ЗначениеЗаполнено(ИсходнаяСтрока) И СтрНайти(ИсходнаяСтрока, " ") > 0 Тогда
// Удаляем все пробелы. Используем СтрЗаменить для всех пробелов.
// Для удаления только крайних пробелов использовали бы СокрЛП().
ОчищеннаяСтрока = СтрЗаменить(ИсходнаяСтрока, " ", "");
// Можно также обрезать до нужной длины, если поле имеет ограничение
ОчищеннаяСтрока = Лев(ОчищеннаяСтрока, 10);
// Если строка изменилась, присваиваем очищенное значение обратно полю
Если ОчищеннаяСтрока <> ИсходнаяСтрока Тогда
Элемент.Значение = ОчищеннаяСтрока;
КонецЕсли;
КонецЕсли;
КонецПроцедуры
Важно: Присвоение Элемент.Значение = ОчищеннаяСтрока; в этом событии может привести к некорректной работе курсора или другим визуальным артефактам, так как поле обновляется в процессе редактирования. Этот метод лучше подходит для ситуаций, когда нежелательно видеть пробелы вообще, и пользователь быстро привыкает к автоматической очистке.
ПриОкончанииРедактирования: Это событие вызывается после завершения ввода текста, например, когда пользователь сходит с элемента управления (нажимает Tab, Enter или кликает на другой элемент). Это более "мягкий" способ очистки, поскольку он не прерывает процесс ввода.
&НаКлиенте
Процедура ПолеВводаПриОкончанииРедактирования(Элемент)
// Получаем текущее значение поля ввода
ИсходнаяСтрока = Элемент.Значение;
// Проверяем, что строка не пустая и содержит пробелы
Если ЗначениеЗаполнено(ИсходнаяСтрока) И СтрНайти(ИсходнаяСтрока, " ") > 0 Тогда
ОчищеннаяСтрока = СтрЗаменить(ИсходнаяСтрока, " ", "");
ОчищеннаяСтрока = Лев(ОчищеннаяСтрока, 10);
Если ОчищеннаяСтрока <> ИсходнаяСтрока Тогда
Элемент.Значение = ОчищеннаяСтрока;
КонецЕсли;
КонецЕсли;
КонецПроцедуры
Этот метод предпочтительнее для пользовательского опыта, так как очистка происходит после того, как пользователь закончил ввод, не мешая ему в процессе набора или вставки.
Для удаления разных типов пробелов и символов, мы можем использовать следующие функции 1С:
СокрЛ(Строка): Удаляет пробелы слева.СокрП(Строка): Удаляет пробелы справа.СокрЛП(Строка): Удаляет пробелы слева и справа.СтрЗаменить(Строка, ЧтоЗаменить, НаЧтоЗаменить): Позволяет заменить все вхождения одной подстроки на другую. Отлично подходит для удаления всех пробелов, включая внутренние (например, СтрЗаменить(Строка, " ", "")). Помните, что неразрывный пробел имеет код символа 160.РегулярноеВыражение.
// Создаем объект регулярного выражения
РегВыр = Новый РегулярноеВыражение;
// Шаблон \s ищет любой пробельный символ (пробел, табуляция, перевод строки и т.д.)
// Флаг "g" (глобальный поиск) обеспечивает замену всех совпадений
РегВыр.Установить("(\s)+", "g"); // Ищем один или несколько пробельных символов
ОчищеннаяСтрока = РегВыр.Заменить(ИсходнаяСтрока, "");
Маски ввода в ПолеВвода позволяют задавать формат представления данных и ограничивать вводимую информацию. Если вы хотите, чтобы в поле ввода могли быть только цифры или буквы, маски могут быть полезны. Они могут автоматически отфильтровывать недопустимые символы, включая пробелы, если маска явно их не разрешает.
Мы можем настроить маску интерактивно в конфигураторе или программно. Символы маски включают:
9: Только цифры.#: Цифры, знаки "+", "-" и пробел (если маска должна их разрешать).@: Алфавит (преобразуется в верхний регистр).N: Алфавит (регистр контролируется).U: Алфавит (преобразуется в верхний регистр).X: Только латиница.Например, если поле должно содержать только 10 цифр, без каких-либо пробелов:
&НаКлиенте
Процедура ПриСозданииНаСервере(Отказ, СтандартнаяОбработка)
Элементы.ПолеВвода.Маска = "9999999999";
КонецПроцедуры
При использовании такой маски, при попытке вставить "123 456789" в поле попадет только "123456789". Маска эффективно отфильтрует пробел. Однако маски эффективны для строгих форматов. Если строка может быть произвольной длины и содержать разные символы, а пробелы нужно удалить, маска может быть слишком ограничивающей или вовсе не решить задачу, если, например, нам нужны и буквы, и цифры, и при этом пробелы должны быть удалены.
Это надежный подход, который позволяет получить полный контроль над процессом без сложных манипуляций с буфером. Суть в следующем:
ВременноеПолеВвода, и делаем его достаточно длинным (например, 20-50 символов), чтобы он мог вместить исходную строку с пробелами.ПриИзменении или ПриОкончанииРедактирования этого временного поля мы считываем его значение, очищаем от пробелов и обрезаем до нужной длины (10 символов в нашем случае).ВременноеПолеВвода, чтобы пользователь видел текущие данные.
// В реквизитах формы
// ОсновноеПоле (тип Строка, длина 10) - наш целевой реквизит объекта
// ВременноеПолеВвода (тип Строка, длина 50) - вспомогательный реквизит формы
&НаКлиенте
Процедура ПриСозданииНаСервере(Отказ, СтандартнаяОбработка)
// При открытии формы копируем значение целевого реквизита во временное поле
Если Объект.ОсновноеПоле <> Неопределено Тогда
ВременноеПолеВвода = Объект.ОсновноеПоле;
КонецЕсли;
КонецПроцедуры
&НаКлиенте
Процедура ВременноеПолеВводаПриИзменении(Элемент)
// Получаем значение из временного поля
ИсходнаяСтрока = Элемент.Значение;
// Очищаем строку от пробелов и обрезаем до 10 символов
ОчищеннаяСтрока = СтрЗаменить(ИсходнаяСтрока, " ", "");
ОчищеннаяСтрока = Лев(ОчищеннаяСтрока, 10);
// Присваиваем очищенное значение основному реквизиту объекта
Объект.ОсновноеПоле = ОчищеннаяСтрока;
// Опционально: можно сразу обновить отображение временного поля
// чтобы пользователь видел очищенный результат, но это может быть навязчиво
// Элемент.Значение = ОчищеннаяСтрока;
// В этом случае, если пользователь продолжит набирать,
// система будет постоянно 'очищать' его ввод.
// Лучше очищать при окончании редактирования или не обновлять временное поле.
КонецПроцедуры
&НаКлиенте
Процедура ВременноеПолеВводаПриОкончанииРедактирования(Элемент)
// Более предпочтительный вариант для обновления временного поля
// Пользователь закончил ввод, показываем ему финальный результат
Если Элемент.Значение <> Объект.ОсновноеПоле Тогда
Элемент.Значение = Объект.ОсновноеПоле; // Присваиваем уже очищенное значение
КонецЕсли;
КонецПроцедуры
Этот подход обеспечивает высокую гибкость и предсказуемость, так как все манипуляции происходят внутри управляемой формы без зависимости от внешних механизмов буфера обмена. Он позволяет пользователю вводить или вставлять текст любой длины и с любыми пробелами, а система автоматически приводит его к требуемому формату при сохранении или отображении.
В некоторых случаях, если исходная строка (например, наименование) может содержать пробелы, которые важны для отображения, но мешают при поиске, мы можем хранить "нормализованный" вид (без пробелов или с определенным форматированием) в отдельном, скрытом или служебном поле. Это похоже на то, как часто поступают с телефонными номерами: для отображения храним "+7 (XXX) XXX-XX-XX", а для поиска и сравнения — "7XXXXXXXXXX".
ОсновнаяСтрока (для отображения) и НормализованнаяСтрока (для поиска/сравнения).ПриИзменении ОсновнойСтроки или перед записью объекта в базу данных (ПередЗаписью) заполняем НормализованнуюСтроку, очищая ее от пробелов.НормализованнуюСтроку.
// В модуле объекта (Сервер)
Процедура ПередЗаписью(Отказ, ПараметрыЗаписи)
// Предположим, что ОсновнаяСтрока - это реквизит объекта, который заполняет пользователь
Если ЗначениеЗаполнено(ЭтотОбъект.ОсновнаяСтрока) Тогда
// Очищаем и нормализуем строку для поиска
ЭтотОбъект.НормализованнаяСтрока = СтрЗаменить(ЭтотОбъект.ОсновнаяСтрока, " ", "");
ЭтотОбъект.НормализованнаяСтрока = Лев(ЭтотОбъект.НормализованнаяСтрока, 10); // Обрезаем, если нужно
Иначе
ЭтотОбъект.НормализованнаяСтрока = "";
КонецЕсли;
КонецПроцедуры
Самый простой и иногда наиболее уместный подход — это приводить строку к нужному виду непосредственно перед ее использованием в запросах, фильтрах или сравнениях. Это позволяет хранить данные в том виде, в котором их ввел пользователь, и очищать их только тогда, когда это действительно необходимо.
Например, если у нас есть поле КодТовара, и пользователь мог ввести его с пробелами, но в базе он хранится без них, то при поиске мы делаем так:
&НаСервере
Функция НайтиТоварПоКоду(КодДляПоиска)
// Очищаем код, введенный пользователем, перед использованием его в запросе
ОчищенныйКод = СтрЗаменить(КодДляПоиска, " ", "");
ОчищенныйКод = СокрЛП(ОчищенныйКод); // Удаляем крайние пробелы
Запрос = Новый Запрос;
Запрос.Текст =
"ВЫБРАТЬ
| Номенклатура.Ссылка
|ИЗ
| Справочник.Номенклатура КАК Номенклатура
|ГДЕ
| Номенклатура.Код = &Код";
Запрос.УстановитьПараметр("Код", ОчищенныйКод);
Результат = Запрос.Выполнить().Выбрать();
Если Результат.Следующий() Тогда
Возврат Результат.Ссылка;
Иначе
Возврат Неопределено;
КонецЕсли;
КонецФункции
Этот подход гарантирует, что поиск всегда будет выполняться по очищенным данным, независимо от того, как они были введены в поле ввода.
Мы с вами рассмотрели различные способы, как реализовать обрезку пробелов при вставке текста из буфера обмена в поле ввода на управляемой форме 1С. Выбор конкретного метода зависит от версии платформы, требований к пользовательскому интерфейсу и допустимой сложности реализации:
СредстваБуфераОбмена для чтения содержимого буфера, но будьте готовы к тому, что событие ПриВставкеИзБуфераОбмена() может не сработать для обычного текста. В таком случае, комбинируйте чтение буфера с событиями постобработки (ПриИзменении, ПриОкончанииРедактирования).ПолеHTMLДокумента или COMОбъект("htmlfile"), но будьте готовы к потенциальным проблемам стабильности и безопасности.ПриИзменении, ПриОкончанииРедактирования) с функциями СокрЛП(), СтрЗаменить() или регулярными выражениями; использование дополнительного реквизита формы; хранение нормализованного вида в отдельном поле; или очистка данных непосредственно перед поиском/записью.В большинстве случаев, если нет жесткой необходимости очищать данные *до* их видимого появления в поле, наиболее сбалансированным решением будет постобработка в событии ПриОкончанииРедактирования или использование дополнительного реквизита формы. Эти подходы обеспечивают надежность, предсказуемость и хороший пользовательский опыт.