Добрый утро!

Необходимо из текста кода убрать излишние пробелы, в т.ч. табуляции и т.п.
Быстрое удаление интересует. Какие известны варианты?

Спасибо!

Перебрать все подряд не быстро?

СтрЗаменить()

regexp)

(0) скопировать код в текстовый документ, пройтись по каждой строке циклом с заменой двух пробелов на один, вставить код обратно, выделить и текст-блок-форматировать (Alt+Shift+F)
может так?

(2) СтрРазделить и СтрСоединить теперь есть. Работает практически мгновенно.

(5) надо ещё быстрее :)

Эээ... "из текста кода убрать" - убрать из текста программно или убрать из текста алгоритма программы? "Ничего не понимаю. Что же это получается?"(цы)

(5) Как она поможет убрать пробелы в: "<таб><таб>МояПеременая = <0160><таб><таб><таб>15;" ?

(1) Это и требуется. Варианты какие есть? - вот вопрос.

(3) Что "регексп"?

аа... у чела предпродакшен))))))))

Обфускацию лепишь чтоле?

(7) "из текста кода" = "из текста, который кодом программы является"

СтрокаБезЛишнихПробелов = СтрЗаменить(СтрокаСЛишнимиПробелами, "  ", " ");

(11) Найти и заменить "<таб><таб>" на "<таб>"

(12) Как это поможет убрать пробелы в: "<таб><таб>МояПеременая = <0160><таб><таб><таб>15;" ?

Расширим задачу расширенным примером:

Требуется убрать пробелы в:

<таб><таб>МояПеременая = <0160><таб><таб><таб>"Текст сообщения !";// Комментарий к этой  строке

чтобы осталось:
МояПеременая="Текст сообщения!";//Комментарий к этой  строке

(14) Про циклы слышал что-нибудь?

*без двойного пробела в комментарии ещё

(16) По делу, пожалуйста.

(15)
Функция БыстроУбратьПробелы(Текст)
ТекстИдеальнй = СтрЗаменить(Текст," ","");
ТекстИдеальнй = СтрЗаменить(ТекстИдеальнй ,Символы.Таб,"");

Возврат ТекстИдеальнй ;
КонецФункции

(19) А НПП кто менять будет?

(8) легко

(15) Если надо сохранить лишние символы внутри "Текст сообщения!" то по простому без написания парсера ЯП никак.

(19) А вот еще:
ТекстИдеальнй = СтрЗаменить(ТекстИдеальнй ,"Текстсообщения!","Текст сообщения!");

(20) Уговорил ))

Функция БыстроУбратьПробелы(Текст)
ТекстИдеальный = СтрЗаменить(Текст," ","");
ТекстИдеальный = СтрЗаменить(ТекстИдеальный ,Символы.Таб,"");
ТекстИдеальный = СтрЗаменить(ТекстИдеальный ,Символы.НПП,"");
ТекстИдеальный = СтрЗаменить(ТекстИдеальный ,"Текстсообщения!","Текст сообщения!");

Возврат ТекстИдеальный;
КонецФункции

(15) мас = СтрРазделить(Текст, Символы.Таб + " " + Символы.НПП + ЕщеКакиеТоСимволыРазделители, Ложь;
     Текст = СтрСоединить(мас);

всё.

(24) в (0) написано ИЗЛИШНИЕ

(25) + Текст = СтрСоединить(мас, " ");  конечно же

Если код на языке 1С и комментарии нафик не нужны то можно компиляцией и декомпиляцией провернуть.

(28)+ Если очень-очень хочется сохранить комменты, то сначала их куда то сохраняем в привязке к строкам, затем компилируем, декомпилируем, чистим комменты и подставляем куда нуна.

(29) Скорее - свой "компилятор" написать нужно. Пока не понимаю, как программно заставить 1С скомпилированный код из текста выдать.

(23) Ваш код упадёт на очередном примере.

(27) Таки, получится в итоге:

МояПеременая = "Текст сообщения !" // Комментарий к этой  строке

- все пробелы обратно вернулись.

(30) https://ru.wikipedia.org/wiki/Синтаксический_анализ

есть же всякие инструменты, которые AST деревья строят. И граммкатику 1с к ним уже прикручивали

(32) так вам все пробелы надо удалить? тогда

Текст = СтрСоединить(мас);

(33)+https://ru.wikipedia.org/wiki/Расширенная_форма_Бэкуса_%E2%80%94_Наура
https://ru.wikipedia.org/wiki/ANTLR

Но писать синтаксический анализатор на 1С это конечно прикольно.

Проще! Коллеги, проще надо! Это всего лишь "убрать максимум" и "не повредить минимум"

Типа того:

Если СправаБуква и СлеваБуква, а МеждуПробел Тогда
   ЭтоТекст
Иначе
   НафигПробел
Конец

(35) Кроме пробелов между словами

(37) Ну и у тебя МояПеременная = "Текст <tab><tab>сообщения !" и надо эти табы внутри оставить.

И как?

Пойми не получится "проще", данная задача не имеет простого решения кроме как применения/покупки готового сложного.

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

очень простой зверь - погугли

(39) Таб - тоже пробел, считаем по задаче. Два Таб-а - один излишен.

Данные    = "     какие - то     левые    пробелы    ";
Данные    = СокрЛП(Данные);
Пока СтрНайти(Данные, "  ") <> 0 Цикл
    Данные    = СтрЗаменить(Данные, "  ", " ");
КонецЦикла;

(43) тебе табы вначале надо оставлять или нет? Если это код программы

Регулярки.. кажутся сложными вначале, а потом... сам поймешь)

(42) Спасибо! Решение трилинейного квадро-кубического уравнения в первых производных погуглите, да. Часик и проблема искусственного интеллекта решена!

(47) вот не понял

тебе здесь рег выражения нужно разъяснить?

(48) Просветления Вам!

(49) Да, если в данной задаче это имеет смысл. Чтоб не пушкой по воробьятам.

*примеры, близкие к задаче
*азы для чайников

Есть ощущение что читал подобное обсуждение где то и там был быстрый метод.

помоему тут http://catalog.mista.ru/profile/28527/

Набор утилит (включая редактор sed и фильтр grep), поставляемых в дистрибутивах UNIX, одним из первых способствовал популяризации регулярных выражений для обработки текстов. Многие современные языки программирования имеют встроенную поддержку регулярных выражений. Среди них ActionScript, Perl, Java[1],PHP, JavaScript, языки платформы .NET Framework[2], Python, Tcl, Ruby, Lua, Gambas, C++ (стандарт 2011 года), Delphi, D, Haxe и другие.

Регулярные выражения используются некоторыми текстовыми редакторами и утилитами для поиска и подстановки текста. Например, при помощи регулярных выражений можно задать шаблоны, позволяющие:

найти все последовательности символов «кот» в любом контексте, как то: «кот», «котлета», «терракотовый»;
найти отдельно стоящее слово «кот» и заменить его на «кошка»;
найти слово «кот», которому предшествует слово «персидский» или «чеширский»;
убрать из текста все предложения, в которых упоминается слово кот или кошка.
Регулярные выражения позволяют задавать и гораздо более сложные шаблоны поиска или замены.

Результатом работы с регулярным выражением может быть:

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

История
Истоки регулярных выражений лежат в теории автоматов, теории формальных языков и классификации формальных грамматик по Хомскому[3].

Эти области изучают вычислительные модели (автоматы) и способы описания и классификации формальных языков. В 1940-х гг. Уоррен Маккалок и Уолтер Питтс описали нейронную систему, используя простой автомат в качестве модели нейрона.

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

Кен Томпсон встроил их в редактор QED, а затем в редактор ed под UNIX. С этого времени регулярные выражения стали широко использоваться в UNIX и UNIX-подобных утилитах, например в expr, awk, Emacs, vi, lex и Perl.

Регулярные выражения в Perl и Tcl происходят от реализации, написанной Генри Спенсером. Филип Хейзел разработал библиотеку PCRE (англ. Perl-compatible regular expressions — Perl-совместимые регулярные выражения), которая используется во многих современных инструментах, таких как PHP и Apache.

В теории формальных языков
Основная статья: Регулярный язык
Регулярные выражения состоят из констант и операторов, которые определяют множества строк и множества операций на них соответственно. На данном конечном алфавите Σ определены следующие константы:

(пустое множество) ∅.
(пустая строка) ε обозначает строку, не содержащую ни одного символа. Эквивалентно «».
(символьный литерал) "a", где "a" — символ алфавита Σ.
(множество) из символов, либо из других множеств.
и следующие операции:

(сцепление, конкатенация) RS обозначает множество {αβ | α ∈ R & β ∈ S}. Например, {"boy", "girl"}{"friend", "cott"} = {"boyfriend", "girlfriend", "boycott", "girlcott"}.
(дизъюнкция, чередование) R|S обозначает объединение R и S. Например, {"ab", "c"}|{"ab", "d", "ef"} = {"ab", "c", "d", "ef"}.[4]
(замыкание Клини, звезда Клини) R* обозначает минимальное надмножество множества R, которое содержит ε и замкнуто относительно конкатенации. Это есть множество всех строк, полученных конкатенацией нуля или более строк из R. Например, {"Run", "Forrest"}* = {ε, "Run", "Forrest", "RunRun", "RunForrest", "ForrestRun", "ForrestForrest", "RunRunRun", "RunRunForrest", "RunForrestRun", …}.
Синтаксис
Представление символов
Основная статья: Представление символов в регулярных выражениях
Обычные символы (литералы) и специальные символы (метасимволы)
Большинство символов в регулярном выражении представляют сами себя за исключением специальных символов [ ] \ / ^ $ . | ? * + ( ) { } (в разных типах регулярных выражений этот набор различается, см. Разновидности регулярных выражений), которые могут быть экранированы символом \ (обратная косая черта) для представления самих себя в качестве символов текста. Можно экранировать целую последовательность символов, заключив её между \Q и \E.

Пример    Соответствие
a\.?    a. или a
a\\\\b    a\\b
a\[F\]    a[F]
\Q+-*/\E    +-*/
Аналогично могут быть представлены другие специальные символы (набор символов, требующих экранирования, может отличаться в зависимости от конкретной реализации). Часть символов, которые в той или иной реализации не требуют экранирования (например, угловые скобки < >), могут быть экранированы из соображений удобочитаемости.

Любой символ
Метасимвол . (точка) означает один любой символ, но в некоторых реализациях исключая символ новой строки.

Вместо символа . можно использовать [\s\S] (все пробельные и непробельные символы, включая символ новой строки).

Символьные классы (наборы символов)
Набор символов в квадратных скобках [ ] именуется символьным классом и позволяет указать интерпретатору регулярных выражений, что на данном месте в строке может стоять один из перечисленных символов. В частности, [абв] задаёт возможность появления в тексте одного из трёх указанных символов, а [1234567890] задаёт соответствие одной из цифр. Возможно указание диапазонов символов: например, [А-Яа-я] соответствует всем буквам русского алфавита, за исключением букв «Ё» и «ё».[5]

Если требуется указать символы, которые не входят в указанный набор, то используют символ ^ внутри квадратных скобок, например [^0-9] означает любой символ, кроме цифр.

Добавление в набор специальных символов путём экранирования — самый бесхитростный способ. Однако в современных регулярных выражениях унаследован также и традиционный подход — см. Традиционные регулярные выражения.

Некоторые символьные классы можно заменить специальными метасимволами:

Символ    Эквивалент    Соответствие
\d    [0-9]    Цифровой символ
\D    [^0-9]    Нецифровой символ
\s    [ \f\n\r\t\v]    Пробельный символ
\S    [^ \f\n\r\t\v]    Непробельный символ
\w    [[:word:]]    Буквенный или цифровой символ или знак подчёркивания
\W    [^[:word:]]    Любой символ, кроме буквенного или цифрового символа или знака подчёркивания
Позиция внутри строки
Следующие символы позволяют спозиционировать регулярное выражение относительно элементов текста: начала и конца строки, границ слова.

Представление    Позиция    Пример    Соответствие
^    Начало текста (или строки при модификаторе ?m)    ^a    aaa aaa
$    Конец текста (или строки при модификаторе ?m)    a$    aaa aaa
\b    Граница слова    a\b    aaa aaa
\ba    aaa aaa
\B    Не граница слова    \Ba\B    aaa aaa
\G    Предыдущий успешный поиск    \Ga    aaa aaa (поиск остановился на 4-й позиции — там, где не нашлось a)
Обозначение группы
Круглые скобки используются для определения области действия и приоритета операций. Шаблон внутри группы обрабатывается как единое целое и может быть квантифицирован. Например, выражение (тр[ау]м-?)* найдёт последовательность вида трам-трам-трумтрам-трум-трамтрум.

Перечисление
Вертикальная черта разделяет допустимые варианты. Например, gray|grey соответствует gray или grey. Следует помнить, что перебор вариантов выполняется слева направо, как они указаны.

Если требуется указать перечень вариантов внутри более сложного регулярного выражения, то его нужно заключить в группу. Например, gray|grey или gr(a|e)y описывают строку gray или grey. В случае с односимвольными альтернативами предпочтителен вариант gr[ae]y, так как сравнение с символьным классом выполняется проще, чем обработка группы с проверкой на все её возможные модификаторы и генерацией обратной связи.

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

Представление    Число повторений    Эквивалент    Пример    Соответствие
?    Ноль или одно    {0,1}    colou?r    color, colour
*    Ноль или более    {0,}    colou*r    color, colour, colouur и т. д.
+    Одно или более    {1,}    colou+r    colour, colouur и т. д. (но не color)
Представление    Число повторений    Пример    Соответствие
{n}    Ровно n раз    colou{3}r    colouuur
{m,n}    От m до n включительно    colou{2,4}r    colouur, colouuur, colouuuur
{m,}    Не менее m    colou{2,}r    colouur, colouuur, colouuuur и т. д.
{,n}    Не более n    colou{,3}r    color, colour, colouur, colouuur
Часто используется последовательность .* для обозначения любого количества любых символов между двумя частями регулярного выражения.

Символьные классы в сочетании с квантификаторами позволяют устанавливать соответствия с реальными текстами. Например, столбцами цифр, телефонами, почтовыми адресами, элементами HTML-разметки и др.

Если символы { } не образуют квантификатора, их специальное значение игнорируется.

Жадная и ленивая квантификация
Пример использования жадных и ленивых выражений
Выражение (<.*>) соответствует строке, содержащей несколько тегов HTML-разметки, целиком.

<p><b>Википедия</b> — свободная энциклопедия, в которой <i>каждый</i> может изменить или дополнить любую статью.</p>

Чтобы выделить отдельные теги, можно применить ленивую версию этого выражения: (<.*?>) Ей соответствует не вся показанная выше строка, а отдельные теги (выделены цветом):

<p><b>Википедия</b> — свободная энциклопедия, в которой <i>каждый</i> может изменить или дополнить любую статью.</p>

В некоторых реализациях квантификаторам в регулярных выражениях соответствует максимально длинная строка из возможных (квантификаторы являются жадными, англ. greedy). Это может оказаться значительной проблемой. Например, часто ожидают, что выражение (<.*>) найдёт в тексте теги HTML. Однако если в тексте есть более одного HTML-тега, то этому выражению соответствует целиком строка, содержащая множество тегов.

<p><b>Википедия</b> — свободная энциклопедия, в которой <i>каждый</i> может изменить или дополнить любую статью.</p>

Эту проблему можно решить двумя способами.

Учитывать символы, не соответствующие желаемому образцу (<[^>]*> для вышеописанного случая).
Определить квантификатор как нежадный (ленивый, англ. lazy) — большинство реализаций позволяют это сделать, добавив после него знак вопроса.
Использование ленивых квантификаторов может повлечь за собой обратную проблему, когда выражению соответствует слишком короткая, в частности, пустая строка.

Жадный    Ленивый
*    *?
+    +?
{n,}    {n,}?
Также общей проблемой как жадных, так и ленивых выражений являются точки возврата для перебора вариантов выражения. Точки ставятся после каждой итерации квантификатора. Если интерпретатор не нашёл соответствия после квантификатора, то он начинает возвращаться по всем установленным точкам, пересчитывая оттуда выражение по-другому.

Ревнивая квантификация (сверхжадная)
При поиске выражения (a+a+)+a в строке aaaaa интерпретатор пойдёт приблизительно по следующему пути:

aaaaa
aaaa
aaaaa
aaa
aaaaa
aaaa
aaaaa — и только тут, проверив все точки возврата, остановится.
При использовании ревнивого квантификатора будет выполнен только первый шаг алгоритма.

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

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

Жадный    Ревнивый
*    *+
?    ?+
+    ++
{n,}    {n,}+
Пример    Соответствие
ab(xa)*+a    abxaabxaa; но не abxaabxaa, так как буква a уже занята
Это аналогично атомарной группировке.

Группировка
Обратная связь
Одно из применений группировки — повторное использование ранее найденных групп символов (подстрок, блоков, отмеченных подвыражений, захватов). При обработке выражения подстро́ки, найденные по шаблону внутри группы, сохраняются в отдельной области памяти и получают номер, начиная с единицы. Каждой подстроке соответствует пара скобок в регулярном выражении. Квантификация группы не влияет на сохранённый результат, то есть, сохраняется лишь первое вхождение. Обычно поддерживается до 9 нумерованных подстрок с номерами от 1 до 9, но некоторые интерпретаторы позволяют работать с бо́льшим количеством. Впоследствии в пределах данного регулярного выражения можно использовать обозначения от \1 до \9 для проверки на совпадение с ранее найденной подстрокой.

Например, регулярное выражение (та|ту)-\1 найдёт строку та-та или ту-ту, но пропустит строку та-ту.

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

Группировка без обратной связи
Если группа используется только для группировки и её результат в дальнейшем не потребуется, то можно использовать группировку вида (?:шаблон). Под результат такой группировки не выделяется отдельная область памяти и, соответственно, ей не назначается номер. Это положительно влияет на скорость выполнения выражения, но понижает удобочитаемость.

Атомарная группировка
Атомарная группировка вида (?>шаблон) также, как и группировка без обратной связи, не создаёт обратных связей. В отличие от неё, такая группировка запрещает возвращаться назад по строке, если часть шаблона уже найдена.

Пример    Соответствие    Создаваемые группы
a(bc|b|x)cc    abccaxcc
abccaxcc

abccaxcc
abccaxcc

a(?:bc|b|x)cc    abccaxcc, abccaxcc    нет
a(?>bc|b|x)cc    abccaxcc
но не abccaxcc: вариант x найден, остальные проигнорированы

нет
a(?>x*)xa    не найдётся axxxa: все x заняты, и нет возврата внутрь группы
Атомарная группировка выполняется ещё быстрее, чем группировка без обратной связи, и сохраняет процессорное время при выполнении остального выражения, так как запрещает проверку любых других вариантов внутри группы, когда один вариант уже найден. Это очень полезно при оптимизации групп со множеством различных вариантов.

Это аналогично ревнивой квантификации.

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

Синтаксис    Описание
(?i)    Включает    нечувствительность выражения к регистру символов (англ. case insensitivity)
(?-i)    Выключает
(?s)    Включает    режим соответствия точки символам переноса строки и возврата каретки
(?-s)    Выключает
(?m)    Символы ^ и $ вызывают соответствие только    после и до символов новой строки
(?-m)    с началом и концом текста
(?x)    Включает    режим без учёта пробелов между частями регулярного выражения и позволяет использовать # для комментариев
(?-x)    Выключает
Группы-модификаторы можно объединять в одну группу: (?i-sm). Такая группа включает режим i и выключает режим s, m. Если использование модификаторов требуется только в пределах группы, то нужный шаблон указывается внутри группы после модификаторов но перед двоеточием. Например, (?-i)(?i:tv)set найдёт TVset, но не TVSET.

Комментарии
Для добавления комментариев в регулярное выражение можно использовать группы-комментарии вида (?#комментарий). Такая группа интерпретатором полностью игнорируется и не проверяется на вхождение в текст. Например, выражение А(?#тут комментарий)Б соответствует строке АБ.

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

Представление    Вид просмотра    Пример    Соответствие
(?=шаблон)    Позитивный просмотр вперёд    Людовик(?=XVI)    ЛюдовикXV, ЛюдовикXVI, ЛюдовикXVIII, ЛюдовикLXVII, ЛюдовикXXL
(?!шаблон)    Негативный просмотр вперёд (с отрицанием)    Людовик(?!XVI)    ЛюдовикXV, ЛюдовикXVI, ЛюдовикXVIII, ЛюдовикLXVII, ЛюдовикXXL
(?<=шаблон)    Позитивный просмотр назад    (?<=Сергей )Иванов    Сергей Иванов, Игорь Иванов
(?<!шаблон)    Негативный просмотр назад (с отрицанием)    (?<!Сергей )Иванов    Сергей Иванов, Игорь Иванов
Поиск по условию
Во многих реализациях регулярных выражений существует возможность выбирать, по какому пути пойдёт проверка в том или ином месте регулярного выражения на основании уже найденных значений.

Представление    Пояснение    Пример    Соответствие
(?:(?=если)то|иначе)    Если операция просмотра успешна, то далее выполняется часть то, иначе выполняется часть иначе. В выражении может использоваться любая из четырёх операций просмотра. Следует учитывать, что операция просмотра нулевой ширины, поэтому части то в случае позитивного или иначе в случае негативного просмотра должны включать в себя описание шаблона из операции просмотра.    (?:(?<=а)м|п)    мам,пап
(?(n)то|иначе)    Если n-я группа вернула значение, то поиск по условию выполняется по шаблону то, иначе по шаблону иначе.    (а)?(?(1)м|п)    мам,пап
Флаги
В некоторых языках (например, в JavaScript) реализованы т. н. «флаги», которые расширяют функции регэкспа. Флаги указываются после регулярного выражения (порядок флагов значения не имеет). Типичные флаги:

g — глобальный поиск (обрабатываются все совпадения с шаблоном поиска).
i — регистр букв не имеет значения;
m — многострочный поиск.
s — текст трактуется как одна строка, в этом случае метасимволу . (точка) соответствует любой одиночный символ, включая символ новой строки;
u — unicode трактовка. Выражение может содержать специальные паттерны, характерные для уникода, `/\p{Lu}/ - заглавные буквы` например.
Флаг указывается после паттерна, например, вот так: /[0-9]$/m

Разновидности регулярных выражений
Базовые регулярные выражения POSIX
(англ. basic regular expressions (BRE)). Традиционные регулярные выражения UNIX. Синтаксис базовых регулярных выражений на данный момент определён POSIX'ом как устаревший, но он до сих пор широко распространён из соображений обратной совместимости. Многие UNIX-утилиты используют такие регулярные выражения по умолчанию.

В данную версию включены метасимволы:

.
[ ]
[^ ]
^ (действует только в начале выражения)
$ (действует только в конце выражения)
*
\{ \} — первоначальный вариант для { }
\( \) — первоначальный вариант для ( )
\n, где n — номер от 1 до 9
Особенности:

Звёздочка должна следовать после выражения, соответствующего единичному символу. Пример: [xyz]*.
Выражение \(блок\)* следует считать неправильным. В некоторых случаях оно соответствует нулю или более повторений строки блок. В других оно соответствует строке блок*.
Внутри символьного класса специальные значения символов, в основном, игнорируются. Особые случаи:
Чтобы добавить символ ^ в набор, его следует поместить туда не первым.
Чтобы добавить символ - в набор, его следует поместить туда первым или последним. Например:
шаблон DNS-имени, куда могут входить буквы, цифры, минус и точка-разделитель: [-0-9a-zA-Z.];
любой символ, кроме минуса и цифры: [^-0-9].
Чтобы добавить символ [ или ] в набор, его следует поместить туда первым. Например:
[][ab] соответствует ], [, a или b.
Расширенные регулярные выражения POSIX
(англ. extended regular expressions (ERE)). Синтаксис в основном аналогичен традиционному.

Отменено использование обратной косой черты для метасимволов { } и ( ).
Обратная косая черта перед метасимволом отменяет его специальное значение (см. Представление специальных символов).
Отвергнута теоретически нерегулярная конструкция \n.
Добавлены метасимволы +, ?, |.
См. также: Символьные классы POSIX
Регулярные выражения, совместимые с Perl
Основная статья: PCRE
Perl-совместимые регулярные выражения (англ. Perl-compatible regular expressions (PCRE)) имеют более богатый синтаксис, чем даже POSIX ERE. По этой причине очень многие приложения используют именно Perl-совместимый синтаксис регулярных выражений.

Регулярные выражения, совместимые с Unicode
Основной источник: Regex Tutorial - Unicode Characters and Properties. http://www.regular-expressions.info. Дата обращения 20 декабря 2018.
Unicode - это набор символов, целью которого является определение всех символов и символов со всех человеческих языков, живых и мертвых. Регулярные выражения, рассчитанные на множество языков, таким образом не привязываются к конкретным наборам символов, а описывают их согласно принятых правил. Так, например выражение для нахождения заглавных букв в любом алфавите будет выглядеть так: `/\p{Lu}/`.

Некоторые выражения regexp - unicode:
представление    функциональность
краткая форма    полная форма
Буквы
\p{L}    \p{Letter}    любые буквы любого языка
\p{Ll}    \p{Lowercase_Letter}    буквы нижнего регистра (строчные) из тех, что имеют прописной вариант написания
\p{Lu}    \p{Uppercase_Letter}    буквы верхнего регистра (прописные) для тех, что имеют строчный вариант написания
\p{Lt}    \p{Titlecase_Letter}    прописная буква, которая появляется с начала слова из строчных букв
\p{L&}    \p{Cased_Letter}    буква, которая имеет как прописной, так и строчный варианты написания
\p{Lm}    \p{Modifier_Letter}    специальные символы, которые используются как буквы
\p{Lo}    \p{Other_Letter}    символ или идеограмма, которая не имеет прописных и строчных вариантов написания
Специальные символы
\p{M}    \p{Mark}    символы, вставленные для комбинирования с другими символами (например акценты, умляуты, оборачивающие скобки)
\p{Mn}    \p{Non_Spacing_Mark}    символ, вставленный для комбинирования с другими символами, не занимая дополнительной ширины
\p{Mc}    \p{Spacing_Combining_Mark}    символы, вставленные для комбинирования с другими символами, занимая дополнительную ширину (как во многих восточных языках)
\p{Me}    \p{Enclosing_Mark}    символы, которые оборачивают символ. Например круг, квадрат и т.п
Пробелы и разделители
\p{Z}    \p{Separator}    любые виды пробелов или невидимых разделителей
\p{Zs}    \p{Space_Separator}    пробельные символы, которые невидимы, но имеют ширину
\p{Zl}    \p{Line_Separator}    символ разделения в виде линии U+2028
\p{Zp}    \p{Paragraph_Separator}    знак параграфа U+2029
Математические символы
\p{S}    \p{Symbol}    математические символы, символы валюты, символы псевдографики (рамки) и т.п.
\p{Sm}    \p{Math_Symbol}    любые математические символы
\p{Sc}    \p{Currency_Symbol}    любые символы валют
\p{Sk}    \p{Modifier_Symbol}    комбинированный символ (пометка) как комбинация самого символа и символа отметки
\p{So}    \p{Other_Symbol}    различные символы, не математические, не символы валют или их комбинации
Цифровые символы
\p{N}    \p{Number}    любые виды цифровых символов в любых языках
\p{Nd}    \p{Decimal_Digit_Number}    цифры от нуля до девятки в любых языках
\p{Nl}    \p{Letter_Number}    число, которое может выглядеть как буквы, например как римские числа
\p{No}    \p{Other_Number}    число, представленное как верхний или нижний индекс, или число, которое не состоит из цифр (исключая числа из идеографических письменностей)
Знаки пунктуации
\p{P}    \p{Punctuation}    любой вид пунктуационных знаков
\p{Pd}    \p{Dash_Punctuation}    любой вид дефисов или тире
\p{Ps}    \p{Open_Punctuation}    любой вид открывающих скобок
\p{Pe}    \p{Close_Punctuation}    любой вид закрывающих скобок
\p{Pi}    \p{Initial_Punctuation}    любой вид открывающих кавычек
\p{Pf}    \p{Final_Punctuation}    любой вид закрывающих кавычек
\p{Pc}    \p{Connector_Punctuation}    пунктуационные символы, такие как знаки подчёркивания или соединения слов
\p{Po}    \p{Other_Punctuation}    любые виды пунктуационных символов, что не являются точками, скобками, кавычками или соединителями
Управляющие символы
\p{C}    \p{Other}    невидимые управляющие символы и неиспользуемые позиции
\p{Cc}    \p{Control}    ASCII или Latin-1 управляющие символы: 0x00–0x1F и 0x7F–0x9F
\p{Cf}    \p{Format}    невидимые индикаторы форматирования
\p{Co}    \p{Private_Use}    любые позиции, зарезервированные для личного использования
\p{Cs}    \p{Surrogate}    половина суррогатных пар в кодировке UTF-16
\p{Cn}    \p{Unassigned}    любые позиции, у которых не назначены символы
Нечёткие регулярные выражения
В некоторых случаях регулярные выражения удобно применить для анализа текстовых фрагментов на естественном языке, то есть написанных людьми, и, возможно, содержащих опечатки либо нестандартные варианты употреблений слов. Например, если проводить опрос (допустим, на веб-сайте) «какой станцией метро вы пользуетесь», может оказаться, что «Невский проспект» посетители могут указать как:

Невский
Невск. просп.
Нев. проспект
наб. Канала Грибоедова («Канал Грибоедова» - это название второго выхода ст. м. Невский проспект)
Здесь обычные регулярные выражения неприменимы, в первую очередь из-за того, что входящие в образцы слова могут совпадать не очень точно (нечётко), но, тем не менее, было бы удобно описывать регулярными выражениями структурные зависимости между элементами образца, например, в нашем случае, указать, что совпадение может быть с образцом «Невский проспект» ИЛИ «Канал Грибоедова», притом «проспект» может быть сокращено до «пр» или отсутствовать, а перед «Канал» может находиться сокращение «наб.»

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

Существует небольшое количество библиотек, реализующих механизм регулярных выражений с возможностью нечёткого сравнения:

TRE — бесплатная библиотека на С, использующая синтаксис регулярных выражений, похожий на POSIX (стабильный проект);
FREJ — open-source библиотека на Java, использующая Lisp-образный синтаксис и лишённая многих возможностей обычных регулярных выражений, но сосредоточенная на различного рода автоматических заменах фрагментов текста (бета-версия).
Реализации
NFA (англ. nondeterministic finite-state automata — недетерминированные конечные автоматы) используют жадный алгоритм отката, проверяя все возможные расширения регулярного выражения в определённом порядке и выбирая первое подходящее значение. NFA может обрабатывать подвыражения и обратные ссылки. Но из-за алгоритма отката традиционный NFA может проверять одно и то же место несколько раз, что отрицательно сказывается на скорости работы. Поскольку традиционный NFA принимает первое найденное соответствие, он может и не найти самое длинное из вхождений (этого требует стандарт POSIX, и существуют модификации NFA, выполняющие это требование — GNU sed). Именно такой механизм регулярных выражений используется, например, в Perl, Tcl и .NET.
DFA (англ. deterministic finite-state automata — детерминированные конечные автоматы) работают линейно по времени, поскольку не используют откаты и никогда не проверяют какую-либо часть текста дважды. Они могут гарантированно найти самую длинную строку из возможных. DFA содержит только конечное состояние, следовательно, не обрабатывает обратных ссылок, а также не поддерживает конструкций с явным расширением, то есть не способен обработать и подвыражения. DFA используется, например, в lex и egrep.

сам напросился, суко

(0)
Была подобная задача у меня, решил ее с помощью регулярных выражений
Книга знаний: Использование регулярных выражений (RegExp) в 1С

(54) Где так копипастить научился?

(57) долго.. в монастыре.. гуру дали скилл .. одним пальцем теперь нажимаю контрол и с

(56) И еще одну задачу решал, проще вот такую процедуру дописывать, пока идеал не увидишь и все

Функция БыстроУбратьПробелы(Текст)
ТекстИдеальный = СтрЗаменить(Текст," = ","=");
ТекстИдеальный = СтрЗаменить(ТекстИдеальный ,<tab><tab>,"<tab>");
ТекстИдеальный = СтрЗаменить(ТекстИдеальный ," !","!");
ТекстИдеальный = СтрЗаменить(ТекстИдеальный ," <","<");
ТекстИдеальный = СтрЗаменить(ТекстИдеальный ,"> ",">");

Выполнить(ТекстИзРеквизитаНаФорме);

Возврат ТекстИдеальный;
КонецФункции

5-10 минут тестирования на реальных примерах и у тебя получиться идеальная функция

Человек просто не дает полные требования к задаче, а хочет идеального решения.
Хочу программу
какую?
простую
Что должна уметь?
Считать
Что считать?
Примеры
Вот такая пойдет?
А как же "решение трилинейного квадро-кубического уравнения в первых производных"?
Ну вы же сказали простую
ААА вы все дебилы ничего не понимаете

для очень похоже на данную ветку)

(59) 25000 модулей не проверишь глазами.

Так, начало статьи про регексп осилил, судя по ней, мне нужна регулярка, вида:

[а-яА-ЯёЁa-zA-z]\s[а-яА-ЯёЁa-zA-z] - допустимо

^[а-яА-ЯёЁa-zA-z]\s[а-яА-ЯёЁa-zA-z]
^[а-яА-ЯёЁa-zA-z]\s^[а-яА-ЯёЁa-zA-z]
[а-яА-ЯёЁa-zA-z]\s^[а-яА-ЯёЁa-zA-z] - пробел не нужен

Туда ли я лезу? И как заменить отсутствием пробела то что описано в регулярке?

^[а-яА-ЯёЁa-zA-Z]\s*[а-яА-ЯёЁa-zA-Z]
^[а-яА-ЯёЁa-zA-Z]\s*^[а-яА-ЯёЁa-zA-Z]
[а-яА-ЯёЁa-zA-Z]\s*^[а-яА-ЯёЁa-zA-Z] - пробел не нужен

в правильном направлении)

\p{L} - любые буквы любого языка, но что такое \р, в данном случае? Ошибка копирования - останки разметки таблицы?

"У программиста была проблема, которую он начал решать регэкспами. Теперь у него две проблемы"...

экранированный символ, указывающий на то, что ты написал

стр= "<таб><таб>МояПеременая = <0160><таб><таб><таб>"Текст сообщения !"// Комментарий к этой  строке";
    
    РВ= новый COMОбъект("VBScript.RegExp");
    
    РВ.IgnoreCase = Истина; //Игнорировать регистр
    РВ.Global = Истина; //Поиск всех вхождений шаблона
    
    РВ.Pattern = "(  ^{L}\s+{L}  ) | (  ^{L}\s+^{L}  ) | (  {L}\s+^{L}  )";
    
    стр= РВ.Replace(стр, "$1"); // как здесь сказать "БЕЗ \s+"?

?

непонял проблемы

Не работает вообще этот паттерн

Ясно, не там ^

(64) \p в регекспах - символ Юникода по категории. \p{L} - Letters, буквы.
Но VBScript.RegExp это не поддерживает.

Осталось непонятным, как заменить по принципу "убрать пробел". Т.к. моё выражение находит места, где данный пробел присутствует, но спереди/сзади цепляет небукву

И в \s нет символа <0160>

(72)

Попробуй шаблоны тестировать вот тут:
http://www.pcre.ru/eval

Я именно здесь настраивал, а потом в 1с вставлял.

Вот процедура из рабочего кода, моя:

Процедура ПроставитьАвторамПробелыНажатие(Элемент)
        Попытка
        RegExp = New COMОбъект("VBScript.RegExp");
    Исключение
        Сообщить(ОписаниеОшибки());
        Возврат;
    КонецПопытки;
    
    
    Запрос = Новый Запрос;
    Запрос.Текст =
    "ВЫБРАТЬ
    |    Б_Авторы.Ссылка,
    |    Б_Авторы.Наименование КАК Наименование
    |ИЗ
    |    Справочник.Б_Авторы КАК Б_Авторы
    |ГДЕ
    |    Б_Авторы.ПометкаУдаления = ЛОЖЬ
    |    И Б_Авторы.Наименование ПОДОБНО ""%.%""
    |
    |УПОРЯДОЧИТЬ ПО
    |    Наименование";
    //Запрос.УстановитьПараметр("",);
    
    РезультатЗапроса = Запрос.Выполнить();
    ТаблицаЗапроса = РезультатЗапроса.Выгрузить();
    
    Для Каждого Состав Из ТаблицаЗапроса Цикл
        ОбработкаПрерыванияПользователя();
        
        Параметры = ПолучитьЗначениеРегулярнымВыражением(СокрЛП(Состав.Наименование),"\.[А-Я]\.",RegExp);
        Если Параметры.ВыполненоУспешно Тогда
            //Если ххСостав.ВыводитьТолькоИмя Тогда
                //мТекстОписания = мТекстОписания + ххСостав.Имя + Символы.ПС;
                //Сообщить(ххСостав.Имя);
                Сообщить(СокрЛП(Состав.Наименование));
                Если Лев(Параметры.Результат,1) = "." Тогда
                    Инициалы = ". " + ДополнительныеПроцедуры.ПравБез(Параметры.Результат,1);
                Иначе
                    Продолжить;
                КонецЕсли;
                НовоеНаименование = СтрЗаменить(СокрЛП(Состав.Наименование),Параметры.Результат,Инициалы);
                Сообщить(СокрЛП(НовоеНаименование));
                
                
                ТекОбъект = Состав.Ссылка.ПолучитьОбъект();
                ТекОбъект.Наименование = СокрЛП(НовоеНаименование);
                ТекОбъект.Записать();
                
        
            
            
        КонецЕсли;
        
        
    КонецЦикла;

КонецПроцедуры

Функция ПолучитьЗначениеРегулярнымВыражением(ВходящийТекст,РегВыражение,RegExp=Неопределено) Экспорт
    
    Если RegExp = Неопределено Тогда  
        RegExp = New COMОбъект("VBScript.RegExp");
    КонецЕсли;
    
    //Дополнительно +
    Параметры = Новый Структура;
    Параметры.Вставить("ВыполненоУспешно",Ложь);
    Параметры.Вставить("ВходящийТекст",ВходящийТекст);
    Параметры.Вставить("Результат","");
    //Дополнительно -
    
    //RegExp.IgnoreCase = Ложь; //Игнорировать регистр
    RegExp.Global = Ложь; //Поиск всех вхождений шаблона
    RegExp.MultiLine = Ложь; //Многострочный режим
    
    RegExp.Pattern = РегВыражение;
    Matches=RegExp.Execute(ВходящийТекст);
    ЧислоВхождений=Matches.Count();
    
    Если ЧислоВхождений = 1 Тогда
        Match = Matches.Item(0);
        Параметры.Результат = СокрЛП(Match.Value);
        Параметры.ВыполненоУспешно = Истина;
    КонецЕсли;
    
    
    
    Возврат Параметры;
КонецФункции

(74) Наименования такие отрабатывала например:

1. (АСТ) Гордеева Е.А., Парнякова М.В., <не указано> Мой секретный дневничок на каждый день `16 7-инт
2. EverAfterHigh(Эксмо) Школа "Долго и счастливо". Дневник моих секретов `16, 7Бц
3. Winx (АСТ) Булеков С. Н. Дневник волшебного питомца. Клуб Winx `12 7БЦ

(76) Получал на выходе:

1. (АСТ) Гордеева Е. А., Парнякова М. В., <не указано> Мой секретный дневничок на каждый день `16 7-инт
2. EverAfterHigh(Эксмо) Школа "Долго и счастливо". Дневник моих секретов `16, 7Бц
3. Winx (АСТ) Булеков С. Н. Дневник волшебного питомца. Клуб Winx `12 7БЦ

(72)
стр= "        МояПеременая =              ""Текст сообщения !""// Комментарий к этой   строке";
РВ= новый COMОбъект("VBScript.RegExp");
РВ.IgnoreCase = Истина;//Игнорировать регистр
РВ.Global = Истина;//Поиск всех вхождений шаблона
РВ.Pattern = "[\s+\xA0]{2,}";
стр= РВ.Replace(стр, "");

(78) Работает неполноценно. Не все излишние пробелы находит.

Что такое \хА0 ?

символ 160, похоже.

(79)(80) "\x" + ваше 0160 в 16ной системе. аналогично можно перечислить другие спецсимволы
опишите четкий критерий какие пробелы считаются излишними

(82) Неразрывный пробел - вполне чётко под критерий "пробельные символы" попадает, но его в \s нет, что странно

Получилось следующее:

(([^а-яА-ЯёЁa-zA-Z\s\xA0])([\s\xA0]+)([а-яА-ЯёЁa-zA-Z]))|(([^а-яА-ЯёЁa-zA-Z\s\xA0])([\s\xA0]+)([^а-яА-ЯёЁa-zA-Z\s\xA0]))|(([а-яА-ЯёЁa-zA-Z])([\s\xA0]+)([^а-яА-ЯёЁa-zA-Z\s\xA0]))|(([\s\xA0])([\s\xA0]+))

- находит (Буква Небуква) (Небуква Буква) (Небуква Небуква), но не находит (Буква Небуква Буква), т.к. мне нужно, чтобы находил только пробельные части, чтобы их заменить на ничто, а в результат включаются и соседние символы.

Не разобрался, как исключать из результатов части вокруг пробельных символов

Также - находит 2-ой и последующие пробельные символы, но в начале и конце строки останутся по первому пробельному символу

Есть же схема описания поиска "найти пробел, ранее которого..., и после которого..." - но не осилил с пониманием закорючк

ов

В итоге поиска - только искомые пробелы. И в схеме (Буква Небуква Буква) - будут две замены на (БукваНебукваБуква), а не как в моём регекспе (БукваНебуква Буква), и требует второй проход.

Ctrl+A, Shift+TAB, Shift+TAB, Shift+TAB, Shift+TAB
Ctrl+H, найти " ", заменить на ""

Если нужно сохранять пробелы в строках, сокращать до одного в комментариях и удалять все остальные, то одним VBScript.RegExp вряд ли можно обойтись. А ещё надо учесть многострочные строки.

(90) Многострочных строк не надо учитывать. Осталось, как и в начале - разобраться, чем РегЕксп тут может помочь. Находит - да, а вот замену как сделать?

Проще парсер написать,который будет разбирать переменные и выражения.

(92) Проще - воспользоваться результатами РегЕхп и 1С-кодом его обработать. Но хочется скорости, чтобы результат уже был обработан. Задача вот - правильный РегЕхп написать, что я пока не осилил. В мануалах написано, что возможно, но примеры не работают, а в мануалах - не поясняется.

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

Не, ну задачу-то не надо усложнять! Только излишние пробелы требуется удалить.

Вот пример (все пробелы двойные):
  МояПеременая  =  "Текст  сообщения  ""c  кавычками  внутри""  //  не  комментарий  //  """  //  Комментарий  к  этой  строке  "со  строкой  //  и  "не  комментарием"  !
Что должно получиться?

Генератор лексических анализаторов в помощь. lex/flex/JFLEX - там все просто

Всё оказалось проще простого:

((?<=[^а-яА-ЯёЁa-zA-Z\s\xA0])[\s\xA0]+)|([\s\xA0]+(?=[^а-яА-ЯёЁa-zA-Z\s\xA0]))|((?<=[\s\xA0])[\s\xA0]+)

Первый и последний пробелы остаются лишь

И с конечными и начальными пробелами:
((?<=[^а-яА-ЯёЁa-zA-Z\s\xA0])[\s\xA0]+)|([\s\xA0]+(?=[^а-яА-ЯёЁa-zA-Z\s\xA0]))|((?<=^|[\s\xA0])[\s\xA0]+)|([\s\xA0]+$)

(96)

МояПеременая="Текст сообщения""c кавычками внутри""//не комментарий//"""//Комментарий к этой строке"со строкой//и"не комментарием"!

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

И хватит простейшего кода в несколько строчек?

Например твой регэксп как обработает?

Моя_Переменая  =  "Текст_сообщения""c_кавычками_внутри"" -// = не__комментарий \ //  """  //  Комментарий  к  этой  строке  "со  строкой  //  и  "не  комментарием"  !

(102)+ И еще могу разных символов навставлять, которые не " " и не Символ(9)

(99) на регэкспах далеко не уедешь.
ибо это путь райт-онли

вот же quest писал такое
JFlex + CUP – генерация кода на 1С.  Востребовано?
как раз по теме (0)

(103) И чо? В чём смысл ваших сообщений?

(102) Ссылки на тестирование работы приводились. Я пользуюсь этим: https://regex101.com

Вспомнилось: "Если у вас есть проблема и вы собираетесь ее решать с помощью регулярных выражений, то теперь у вас две проблемы"

(100) Т.е. пробелы внутри строк тоже сокращаются. Тогда неинтересно.

Однако, почему-то 1С на данную конструкцию ругается, синтакс еррор... мдя..

(110) Точка с запятой - на следующей строке. С ней все нормально.

Что за шайтанство - синтакс еррор (0x800a1399) на "((?<=[^а-яА-ЯёЁa-zA-Z\s\xA0])[\s\xA0]+)|([\s\xA0]+(?=[^а-яА-ЯёЁa-zA-Z\s\xA0]))|((?<=^|[\s\xA0])[\s\xA0]+)|([\s\xA0]+$)" и всё норм лишь на "[\s\xA0]+"?

(112) Добро пожаловать в прекрасный мир различных диалектов regexp :)
Начать с того, что в VBScript.RegExp кажись "|" не поддерживается.

Хотя нет, в группах поддерживается...

?<= не поддерживается, но пояснений нет пока....

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

См. (0)
Упёрлись в то, что не найти пробельную последовательность, идущую после символа к букве, конструкция ?<= не работает, и замены её я не вижу.

*просто "после символа", без разницы до куда.

(117) Ты понимаешь то замена двух пробелов на один дает всегда один пробел, сколько ее раз не применяй?

А можно таб+пробел > пробел, пробле+таб > пробел и т.д. заменять несколько раз.
И будет тебе что требуется простейшим образом без извратов.

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

длстп=СтрДлина(СтрокаДляОбработки);
Начало=НЕОПРЕДЕЛЕНО;
Состояние=1;
Для Поз=1 ПО длстр Цикл
код=КодСимвола(СтрокаДляОбработки,Поз);
Если ЭтоСимволПробела(код)=ИСТИНА Тогда
  Если Начало<>НЕОПРЕДЕЛЕНО Тогда
   рез=рез+Сред(СтрокаДляОбработки,Начало,Поз-Начало);
   Начало=НЕОПРЕДЕЛЕНО;
  КонецЕсли;
  Если Состояние=2 Тогда
   Состояние=3;
  КонецЕсли;
ИначеЕсли Начало=НЕОПРЕДЕЛЕНО Тогда
  Если Состояние=3 Тогда
   рез=рез+" ";
  КонецЕсли;
  Состояние=2;
  Начало=Поз;
КонецЕсли;
КонецЦикла;
Если Начало<>НЕОПРЕДЕЛЕНО Тогда
рез=рез+Сред(СтрокаДляОбработки,Начало);
КонецЕсли;
// рез-наша строка.

(119) Не понял, о чём вы вообще. Какие два пробела? Если задача простейшая, то где ответ за 116 постов, может, у вас есть?

(120) Так и не рассмотрел, в чём секрет. Читаю-читаю, получается у меня, что "это строка" вашим кодом превратится в "этострока".

+к 122: (120) Независимо от того, что скрывается под ЭтоСимволПробела(), т.к. туда сама строка не передаётся, предыдущий, последующий символ - тоже. Да и данный код на 10000 строках - любой сервер обескуражит.

(121) 1. Если в комментариях и внутри значений строковых переменных можно и нужно удалять пробелы - задача простейшая.

2. Если эти лишние пробелы внутри значений строковых переменных (Перем1 = "Вася  ты <tab> зачем пробелы тут убрал    ?";) надо сохранить - задача нереально сложная.

(124) А задачу читали? Она в (0) описана, да и в заголовке тоже.
И даже решение, при помощи волшебного пинка в сторону регексп - разработано, но не работает на ВБСкрипт.Регексп. Нужен аналог команды "?<=<данные>", работающий в ВБСкрипт.Регексп, команды "поиск последовательности только в том случае, если перед последовательностью <данные>"

(125) 1. Ну скажи где в (0) описано (момент со строковыми значениями переменных), неоднократно этот вопрос задавали.

2. Все что вы смогли (точнее не смогли) сделать через регулярки, делается простейше через СтрЗаменить.
И про это вам сразу и сказали. Но кто то или не слышит или притворяется и троллит.

(126) Троллите, пока что, вы меня. В (0) описано что делать со строкой. Пример был дан в течении постов, решение примера, который мне предложили, с вопросом "Что должно получиться?". Что не понятно в части "излишние пробелы"? Какая разница, в тексте они, в строке, в числе?

(127) >Что не понятно в части "излишние пробелы"? Какая разница, в тексте они, в строке, в числе?

У нас походу недопонимание. Я считал вас программистом. Ошибался, сорри.

(128) Взаимно, не отчаивайтесь))

(129) Просто кое кто недоговаривает и не правильно понимает задачу.

Судя по (61) где "25000 модулей не проверишь глазами." вам нужен именно (33) а простыми регэкспами задачку не решить.

Потому что внутри "25000 модулей" точно будут "строковые значения переменных" с "лишними символами внутри".

(130) Предложение в 33 излишне для данной задачи. "строковые значения переменных" с из"лишними символами внутри" - почувствуйте разницу - вполне укладываются в задачу. Мне не понятно, что вам не понятно в слове "излишние".

Излишний:
1. превышающий нужное количество чего-либо, потребность в чём-либо; избыточный, чрезмерный.
2. такой, без которого можно обойтись; ненужный.
3. перен. такой, присутствие которого нежелательно

- не вижу противоречий даже при наличии столь интересных вам "строковых значений переменных"

(131) Мне непонятно что вам непонятно если простое и понятное решение приводилось несколько раз.

А с учетом "25000 модулей не проверишь глазами." - это же ваши слова да?

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

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

(132) Вы мне напоминаете личностей которые да на словах то много говорят и вроде бы даже умно.
Но как поймешь так чушь полная и на деле ничего не могут. Кроме копипастой заниматься.

ну что уже прикрутили парсер или все еще на регэкспах пишите?

(134) Пока что - на деле именно вы себя показываете так, вместо чего-то по теме - пустой трёп ниочём.
Забавно читать, что вы указываете мне, постановщику задачи, что я не правильно понимаю её постановку - это финиш, мистянин! Далее уж лучше и не продолжать троллить.

(135) Я уже неоднократно писал, что на 1С парсер не справится. А регексп - не даёт необходимой функциональности, обратной информации не поступало.

Шанс на ВК остаётся. Правда, если бы хоть конструктор какой, типа "код на Си вставляешь и компилишь"...

О, нашёл и про ВК. Но, не сегодня))

(136) (137) (138) Гыгы. Все с вами понятно, свой ник оправдали на 200%

(0) слишкоммногасообщений уже. Предложу решение, если оно нужно разово:
- копируем код в sublime text3
- ставим плагин для понимания синтаксиса 1С, и выбираем View - Syntax - Language 1C (BSL) - 1C (BSL)
- заменяем "<space><space>" на "<space>" до тех пор пока не станет "вхождений не найдено"
- то же самое делаем с "<tab><tab>"
- то же самое делаем с ненужными непечатными символами (не думаю что их великое разнообразие оказалось в коде)
- затем нажимаем Edit - Line - Reindent и код выстроится с необходимой табуляцией.

Любой нормальный человек молча решит эту задачу за час и никого не спросит. Но мы наколотим ветку в тыщу постов с регехпами и парсерами :)
Господа, вы звери.

(141) Час это уже с выполнением кода на 25000 файлах, писать тут минут 10 максимум.

(142)+ Если конечно снова не всплывет вопрос что иногда лишние пробелы надо оставлять.

(143) ага. или высплывет вопрос "а нафиг оно вообще надо? и так сойдет"

А про какой парсер тут речь в последних 10 постах? Всю ветку не читал, сорри

(144) Ну меня пугает мысль что вот эти лишние символы это некая DRM система хитрая или цифровой подписи и кто пытается ее снять.
Иначе нафига их убирать если и так все работает?

(145) См (102) я так и не понял надо ли убирать
Перем ="1     2";
лишние пробелы тут внутри значения строковой переменной.

(147) сорри *"лишние пробелы"

(147) ну уж конечно не надо убирать. это же текст программы. в строковых константах оставлять однозначно

(141) Так - предложите же, хотя бы, принципиальное решение, или вы не "нормальный человек"?
(145) Ну, парсер - не парсер, но регексп уже попытался заюзать - недостаточен функционал у ВБСкрипт.Регексп оказался.
(149) Кто такую глупость вам сказал? В этой строке - все видимые глазом пробелы - излишние.

(147) (150) Так под "парсером" подразумевается надстройка, выполняющая-обрабатывающая код как текст что ли?

(151) "Я не в курсе, ребята!" ))
Но - обработать нужно текст, являющийся кодом 1С.

(152) Ну так заплати и тебе все сделают как надо.
Или любимое домашнее животное возмущается?

(152) "обработать нужно текст, являющийся кодом 1С" // Выгрузить конфу в файлы, обработать кодом 1С уже предлагали? :)

(154) Чуть реже чем замену "  " на " " и "<tab><tab>" на " "

(150) "В этой строке - все видимые глазом пробелы - излишние."
так программа неправильно работать будет, если удалить эти пробелы. или вам пробелы удалять чисто из спортивного интереса?

(156) Не пойму, потеря какого из пробелов вызывает у вас опасение за работу программы?

Хороший ТС, и вопросы интересные.
(150) "В этой строке - все видимые глазом пробелы - излишние"
Ок, какие лишние пробелы в строке
"ВЫБРАТЬ * ИЗ Документ.ЗаказПокупателя"
?

(158) "ВЫБРАТЬ * ИЗ Документ.ЗаказПокупателя Как Заказ ГДЕ Заказ.Номер Подобно ""%  %"""

(158) имхо, в этой строке нет лишних символов.
(159) тут тоже, ведь кавычки не "излишние пробелы, в т.ч. табуляции и т.п."

(160)
Внутри ""%  %"" у мен два пробела и отличается визуально слегка от
Внутри ""% %"" один пробел

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

(162) Тут задачку надо от обратного решать, искать через регулярки то что не надо чистить.
Регулярка должна вернуть набор подстрок которые не правятся.
Далее ищем эти подстроки по очереди в тексте, выделяем кодом то что между ними и правим заменой.

Но ТС не справится.

(163)+ Но да это тот же лексер, только неполный и на регэкспах

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

(157) если пользователь получит сообщение "Файлненайден.Проверьтеправильностьименифайлаиповторитепопытку.", то это нормально.

Балаболы, задачу-то читали, или так - потрещать?
Следующие требования, файл не найден.... Вы к чему это всё? Прочтите задачу.
Но, за ап темы - спасибо, вдруг знаток вбрегексп заскочит

(167) А где описание задачи?

Всё ясно с вами

(169) И тебе не хворать, гений :)

(169) https://www.anekdot.ru/id/676992/ лети, голубь

Всё уже давно с вами ясно, не стоит это ещё больше показывать. Засираете тему только своим бредом

(171)нет чтоб помочь человеку, раз уж подобную задачу делал

(173) Дык я делал подобную задачу двумя способами через СтрЗаменить и лексер/парсер.

(173) для тебя решение задачи - бред. Никого кроме себя не слышишь. Схватил регэкспы - и носишься с ними. И как тебе помочь? Посоветовать книжки почитать? так это очень сложный путь и тебе не осилить. Проще написать (172)

(172) потому что в первых 10 сообщениях были озвучены рабочие решения.
а в первой сотне даже куски кода готовые.

Когда-то давно решал похожую задачку v8: Быстрый способ обработки Таблиц значений, Массивов

(173) Как раз - наоборот! Для меня решение задачи - очень важно, а для вас - выглядит бредом. Если по делу нечего написать, лучшей помощью будет - не засирать тему бессмыслицей. Спасибо за понимание!

(176) Покажите, будьте так любезны, где я пропустил рабочее решение? Ткните носом, если вам так приятнее будет. Осторожнее - лужи!

(177) У вас все пробелы удалить задача - это просто, у нас - только излишние, "РегистрНакопления.Останки КАК Останки" - должно остаться с пробелами, т.к. "РегистрНакопления.ОстанкиКАКОстанки" - это уже названием таблицы становится. Как в данном примере - не принципиально для решения, но вдруг могут случиться такие примеры, где это скажется негативно. Пока - примера подобного не видел, но со счетов сбрасывать опасаюсь. Условие "читабельность" нарушается, и это единственная причина, что сразу не было сделано именно так.

пятый день пошел