├── tasks ├── oscript.cfg ├── coverage.os └── test.os ├── .gitattributes ├── .gitignore ├── lib.config ├── .bsl-language-server.json ├── src ├── internal │ ├── Классы │ │ ├── ШагКонвейераПолучитьПервый.os │ │ ├── ШагКонвейераКоличество.os │ │ ├── ШагКонвейераБарьерВернутьЗначение.os │ │ ├── ШагКонвейераВСтроку.os │ │ ├── ШагКонвейераПервые.os │ │ ├── ШагКонвейераПропустить.os │ │ ├── ШагКонвейераДляКаждого.os │ │ ├── ШагКонвейераОбработать.os │ │ ├── ШагКонвейераФильтровать.os │ │ ├── ШагКонвейераСократить.os │ │ ├── ШагКонвейераРазвернуть.os │ │ ├── ШагКонвейераЛюбойСоответствует.os │ │ ├── ШагКонвейераРазличные.os │ │ ├── ШагКонвейераПолучить.os │ │ └── ШагКонвейераСортировать.os │ └── Модули │ │ ├── ДействияКонвейера.os │ │ └── ПроцессорыКоллекцийСлужебный.os ├── Модули │ └── ПроцессорыКоллекций.os └── Классы │ └── ПроцессорКоллекций.os ├── .github └── workflows │ ├── rebase.yml │ ├── testing.yml │ ├── release.yml │ └── qa.yml ├── packagedef ├── sonar-project.properties ├── tests ├── Инициализация.os ├── ОбработкаСтроки.os ├── КонвейерныеМетоды.os ├── ИнтеграционныйТест.os └── ТерминальныеМетоды.os ├── LICENSE ├── CHANGELOG.md ├── examples ├── test.os └── github.os └── README.md /tasks/oscript.cfg: -------------------------------------------------------------------------------- 1 | lib.system=../oscript_modules 2 | -------------------------------------------------------------------------------- /.gitattributes: -------------------------------------------------------------------------------- 1 | *.os text eol=lf 2 | *.md text eol=lf 3 | *.json text eol=lf 4 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | 2 | *.ospx 3 | build/ 4 | .sonar/ 5 | .sonarlint/ 6 | .vscode 7 | oscript_modules/ -------------------------------------------------------------------------------- /lib.config: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | -------------------------------------------------------------------------------- /.bsl-language-server.json: -------------------------------------------------------------------------------- 1 | { 2 | "diagnostics": { 3 | "parameters": { 4 | "IncorrectLineBreak": { 5 | "listOfIncorrectFirstSymbol": ";" 6 | } 7 | } 8 | } 9 | } -------------------------------------------------------------------------------- /src/internal/Классы/ШагКонвейераПолучитьПервый.os: -------------------------------------------------------------------------------- 1 | Функция Принять(Элемент) Экспорт 2 | Возврат Новый Структура("Действие, Значение", ДействияКонвейера.ВернутьЗначение, Элемент); 3 | КонецФункции 4 | 5 | Функция Барьерный() Экспорт 6 | Возврат Ложь; 7 | КонецФункции 8 | 9 | Процедура Деструктор() Экспорт 10 | // no-op 11 | КонецПроцедуры 12 | 13 | Процедура ПриСозданииОбъекта() 14 | КонецПроцедуры -------------------------------------------------------------------------------- /src/internal/Классы/ШагКонвейераКоличество.os: -------------------------------------------------------------------------------- 1 | Функция Принять(Коллекция) Экспорт 2 | Возврат Новый Структура( 3 | "Действие, Значение", 4 | ДействияКонвейера.ВернутьЗначение, 5 | Коллекция.Количество() 6 | ); 7 | КонецФункции 8 | 9 | Функция Барьерный() Экспорт 10 | Возврат Истина; 11 | КонецФункции 12 | 13 | Процедура Деструктор() Экспорт 14 | // no-op 15 | КонецПроцедуры 16 | 17 | Процедура ПриСозданииОбъекта() 18 | КонецПроцедуры -------------------------------------------------------------------------------- /src/internal/Классы/ШагКонвейераБарьерВернутьЗначение.os: -------------------------------------------------------------------------------- 1 | Перем Значение; 2 | 3 | Функция Принять(Коллекция) Экспорт 4 | Возврат Новый Структура("Действие, Значение", ДействияКонвейера.ВернутьЗначение, Значение); 5 | КонецФункции 6 | 7 | Функция Барьерный() Экспорт 8 | Возврат Истина; 9 | КонецФункции 10 | 11 | Процедура Деструктор() Экспорт 12 | // no-op 13 | КонецПроцедуры 14 | 15 | Процедура ПриСозданииОбъекта(пЗначение) 16 | Значение = пЗначение; 17 | КонецПроцедуры -------------------------------------------------------------------------------- /src/internal/Модули/ДействияКонвейера.os: -------------------------------------------------------------------------------- 1 | Перем ЗаменитьКоллекцию Экспорт; 2 | Перем ПропуститьЭлемент Экспорт; 3 | Перем ПрекратитьОбход Экспорт; 4 | Перем ЗаменитьЭлемент Экспорт; 5 | Перем Бездействие Экспорт; 6 | Перем ВернутьЗначение Экспорт; 7 | 8 | ЗаменитьКоллекцию = "ЗаменитьКоллекцию"; 9 | ПропуститьЭлемент = "ПропуститьЭлемент"; 10 | ПрекратитьОбход = "ПрекратитьОбход"; 11 | ЗаменитьЭлемент = "ЗаменитьЭлемент"; 12 | Бездействие = "Бездействие"; 13 | ВернутьЗначение = "ВернутьЗначение"; 14 | -------------------------------------------------------------------------------- /src/internal/Классы/ШагКонвейераВСтроку.os: -------------------------------------------------------------------------------- 1 | Перем РазделительСтрок; 2 | 3 | Функция Принять(Коллекция) Экспорт 4 | 5 | Возврат Новый Структура( 6 | "Действие, Значение", 7 | ДействияКонвейера.ВернутьЗначение, 8 | СтрСоединить(Коллекция, РазделительСтрок) 9 | ); 10 | 11 | КонецФункции 12 | 13 | Функция Барьерный() Экспорт 14 | Возврат Истина; 15 | КонецФункции 16 | 17 | Процедура Деструктор() Экспорт 18 | // no-op 19 | КонецПроцедуры 20 | 21 | Процедура ПриСозданииОбъекта(пРазделительСтрок) 22 | РазделительСтрок = пРазделительСтрок; 23 | КонецПроцедуры -------------------------------------------------------------------------------- /.github/workflows/rebase.yml: -------------------------------------------------------------------------------- 1 | name: Automatic Rebase 2 | on: 3 | issue_comment: 4 | types: [created] 5 | jobs: 6 | rebase: 7 | name: Rebase 8 | if: github.event.issue.pull_request != '' && contains(github.event.comment.body, '/rebase') 9 | runs-on: ubuntu-latest 10 | steps: 11 | - name: Checkout the latest code 12 | uses: actions/checkout@v3 13 | with: 14 | token: ${{ secrets.GITHUB_TOKEN }} 15 | fetch-depth: 0 # otherwise, you will fail to push refs to dest repo 16 | - name: Automatic Rebase 17 | uses: cirrus-actions/rebase@1.8 18 | env: 19 | GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} 20 | -------------------------------------------------------------------------------- /packagedef: -------------------------------------------------------------------------------- 1 | 2 | Описание.Имя("fluent") 3 | .Версия("0.6.1") 4 | .Описание("Библиотека для работы с коллекциями в ""текучем"" стиле") 5 | .Автор("Nikita Gryzlov") 6 | .АдресАвтора("nixel2007@gmail.com") 7 | .ВерсияСреды("1.0.18") 8 | .ЗависитОт("logos") 9 | .ЗависитОт("notify", "0.2.0") 10 | .ЗависитОт("lambdas", "0.1.2") 11 | .ЗависитОт("strings") 12 | .ЗависитОт("tempfiles") 13 | .РазработкаЗависитОт("1commands") 14 | .РазработкаЗависитОт("1testrunner") 15 | .РазработкаЗависитОт("coverage") 16 | .ВключитьФайл("examples") 17 | .ВключитьФайл("src") 18 | .ВключитьФайл("tasks") 19 | .ВключитьФайл("tests") 20 | .ВключитьФайл("lib.config") 21 | -------------------------------------------------------------------------------- /src/internal/Классы/ШагКонвейераПервые.os: -------------------------------------------------------------------------------- 1 | Перем мКоличество; 2 | Перем КоличествоПринято; 3 | 4 | Функция Принять(Элемент) Экспорт 5 | 6 | Если КоличествоПринято = мКоличество Тогда 7 | Возврат Новый Структура("Действие", ДействияКонвейера.ПрекратитьОбход); 8 | КонецЕсли; 9 | 10 | КоличествоПринято = КоличествоПринято + 1; 11 | 12 | Возврат Новый Структура("Действие", ДействияКонвейера.Бездействие); 13 | 14 | КонецФункции 15 | 16 | Функция Барьерный() Экспорт 17 | Возврат Ложь; 18 | КонецФункции 19 | 20 | Процедура Деструктор() Экспорт 21 | // no-op 22 | КонецПроцедуры 23 | 24 | Процедура ПриСозданииОбъекта(Количество) 25 | мКоличество = Количество; 26 | КоличествоПринято = 0; 27 | КонецПроцедуры -------------------------------------------------------------------------------- /sonar-project.properties: -------------------------------------------------------------------------------- 1 | # must be unique in a given SonarQube instance 2 | sonar.projectKey=oscript-fluent 3 | 4 | # this is the name displayed in the SonarQube UI 5 | sonar.projectName=fluent 6 | 7 | # Path is relative to the sonar-project.properties file. Replace "\" by "/" on Windows. 8 | # Since SonarQube 4.2, this property is optional if sonar.modules is set. 9 | # If not set, SonarQube starts looking for source code from the directory containing 10 | # the sonar-project.properties file. 11 | 12 | sonar.sources=./src 13 | 14 | # Encoding of the source code. Default is default system encoding 15 | sonar.sourceEncoding=UTF-8 16 | 17 | sonar.coverageReportPaths=build/coverage/genericCoverage.xml 18 | -------------------------------------------------------------------------------- /src/internal/Классы/ШагКонвейераПропустить.os: -------------------------------------------------------------------------------- 1 | Перем мКоличество; 2 | Перем КоличествоПропущено; 3 | 4 | Функция Принять(Элемент) Экспорт 5 | 6 | Если КоличествоПропущено = мКоличество Тогда 7 | Возврат Новый Структура("Действие", ДействияКонвейера.Бездействие); 8 | КонецЕсли; 9 | 10 | КоличествоПропущено = КоличествоПропущено + 1; 11 | 12 | Возврат Новый Структура("Действие", ДействияКонвейера.ПропуститьЭлемент); 13 | 14 | КонецФункции 15 | 16 | Функция Барьерный() Экспорт 17 | Возврат Ложь; 18 | КонецФункции 19 | 20 | Процедура Деструктор() Экспорт 21 | // no-op 22 | КонецПроцедуры 23 | 24 | Процедура ПриСозданииОбъекта(Количество) 25 | мКоличество = Количество; 26 | КоличествоПропущено = 0; 27 | КонецПроцедуры -------------------------------------------------------------------------------- /src/internal/Классы/ШагКонвейераДляКаждого.os: -------------------------------------------------------------------------------- 1 | #Использовать lambdas 2 | 3 | Перем Действие; 4 | 5 | Функция Принять(Элемент) Экспорт 6 | 7 | Действие.Выполнить(Элемент); 8 | 9 | Возврат Новый Структура("Действие", ДействияКонвейера.Бездействие); 10 | 11 | КонецФункции 12 | 13 | Функция Барьерный() Экспорт 14 | Возврат Ложь; 15 | КонецФункции 16 | 17 | Процедура Деструктор() Экспорт 18 | ОсвободитьОбъект(Действие); 19 | КонецПроцедуры 20 | 21 | Процедура ПриСозданииОбъекта(ФункцияОбработки, ДополнительныеПараметры, Отладка) 22 | 23 | Действие = ПроцессорыКоллекцийСлужебный.ДействиеИзПараметров( 24 | ФункцияОбработки, 25 | ФункциональныеИнтерфейсы.УниПроцедура(), 26 | ДополнительныеПараметры, 27 | Отладка 28 | ); 29 | 30 | КонецПроцедуры -------------------------------------------------------------------------------- /src/internal/Классы/ШагКонвейераОбработать.os: -------------------------------------------------------------------------------- 1 | #Использовать lambdas 2 | 3 | Перем Действие; 4 | 5 | Функция Принять(Элемент) Экспорт 6 | 7 | Возврат Новый Структура("Действие, Элемент", ДействияКонвейера.ЗаменитьЭлемент, Действие.Выполнить(Элемент)); 8 | 9 | КонецФункции 10 | 11 | Функция Барьерный() Экспорт 12 | Возврат Ложь; 13 | КонецФункции 14 | 15 | Процедура Деструктор() Экспорт 16 | 17 | ОсвободитьОбъект(Действие); 18 | 19 | Действие = Неопределено; 20 | 21 | КонецПроцедуры 22 | 23 | Процедура ПриСозданииОбъекта(ФункцияОбработки, ДополнительныеПараметры, Отладка) 24 | 25 | Действие = ПроцессорыКоллекцийСлужебный.ДействиеИзПараметров( 26 | ФункцияОбработки, 27 | ФункциональныеИнтерфейсы.УниФункция(), 28 | ДополнительныеПараметры, 29 | Отладка 30 | ); 31 | 32 | КонецПроцедуры 33 | -------------------------------------------------------------------------------- /src/internal/Классы/ШагКонвейераФильтровать.os: -------------------------------------------------------------------------------- 1 | #Использовать lambdas 2 | 3 | Перем Действие; 4 | 5 | Функция Принять(Элемент) Экспорт 6 | 7 | Если Действие.Выполнить(Элемент) Тогда 8 | Возврат Новый Структура("Действие", ДействияКонвейера.Бездействие); 9 | КонецЕсли; 10 | 11 | Возврат Новый Структура("Действие", ДействияКонвейера.ПропуститьЭлемент); 12 | 13 | КонецФункции 14 | 15 | Функция Барьерный() Экспорт 16 | Возврат Ложь; 17 | КонецФункции 18 | 19 | Процедура Деструктор() Экспорт 20 | 21 | ОсвободитьОбъект(Действие); 22 | 23 | Действие = Неопределено; 24 | 25 | КонецПроцедуры 26 | 27 | Процедура ПриСозданииОбъекта(ФункцияФильтрации, ДополнительныеПараметры, Отладка) 28 | 29 | Действие = ПроцессорыКоллекцийСлужебный.ДействиеИзПараметров( 30 | ФункцияФильтрации, 31 | ФункциональныеИнтерфейсы.УниФункция(), 32 | ДополнительныеПараметры, 33 | Отладка 34 | ); 35 | 36 | КонецПроцедуры 37 | -------------------------------------------------------------------------------- /src/internal/Классы/ШагКонвейераСократить.os: -------------------------------------------------------------------------------- 1 | Перем Действие; 2 | Перем НачальноеЗначение; 3 | 4 | Функция Принять(Коллекция) Экспорт 5 | 6 | Результат = НачальноеЗначение; 7 | Для Каждого Элемент Из Коллекция Цикл 8 | Результат = Действие.Выполнить(Результат, Элемент); 9 | КонецЦикла; 10 | 11 | Возврат Новый Структура( 12 | "Действие, Значение", 13 | ДействияКонвейера.ВернутьЗначение, 14 | Результат 15 | ); 16 | 17 | КонецФункции 18 | 19 | Функция Барьерный() Экспорт 20 | Возврат Истина; 21 | КонецФункции 22 | 23 | Процедура Деструктор() Экспорт 24 | 25 | ОсвободитьОбъект(Действие); 26 | Действие = Неопределено; 27 | 28 | КонецПроцедуры 29 | 30 | Процедура ПриСозданииОбъекта(ФункцияСокращения, ДополнительныеПараметры, пНачальноеЗначение, Отладка) 31 | 32 | Действие = ПроцессорыКоллекцийСлужебный.ДействиеИзПараметров( 33 | ФункцияСокращения, 34 | ФункциональныеИнтерфейсы.БиФункция(), 35 | ДополнительныеПараметры, 36 | Отладка, 37 | Истина 38 | ); 39 | 40 | НачальноеЗначение = пНачальноеЗначение; 41 | 42 | КонецПроцедуры 43 | -------------------------------------------------------------------------------- /tests/Инициализация.os: -------------------------------------------------------------------------------- 1 | #Использовать asserts 2 | #Использовать ".." 3 | 4 | &Тест 5 | Процедура ТестДолжен_ПроинициализироватьПроцессорКоллекций() Экспорт 6 | ПроцессорКоллекций = Новый ПроцессорКоллекций; 7 | КонецПроцедуры 8 | 9 | &Тест 10 | Процедура ТестДолжен_ПроинициализироватьПроцессорКоллекцийЧерезПомощник() Экспорт 11 | ПроцессорКоллекций = ПроцессорыКоллекций.ИзКоллекции(Новый Массив); 12 | Ожидаем.Что(ПроцессорКоллекций).ИмеетТип("ПроцессорКоллекций"); 13 | КонецПроцедуры 14 | 15 | &Тест 16 | Процедура ТестДолжен_ПроинициализироватьПроцессорКоллекцийИзСтрокиЧерезПомощник() Экспорт 17 | ПроцессорКоллекций = ПроцессорыКоллекций.ИзСтроки(""); 18 | Ожидаем.Что(ПроцессорКоллекций).ИмеетТип("ПроцессорКоллекций"); 19 | КонецПроцедуры 20 | 21 | &Тест 22 | Процедура ТестДолжен_ПроинициализироватьПроцессорКоллекцийИзНабораЧерезПомощник() Экспорт 23 | ПроцессорКоллекций = ПроцессорыКоллекций.ИзНабора(1, 2, 3); 24 | Ожидаем.Что(ПроцессорКоллекций).ИмеетТип("ПроцессорКоллекций"); 25 | Ожидаем.Что(ПроцессорКоллекций.Количество()).Равно(3); 26 | КонецПроцедуры 27 | -------------------------------------------------------------------------------- /tasks/coverage.os: -------------------------------------------------------------------------------- 1 | #Использовать coverage 2 | #Использовать 1commands 3 | #Использовать fs 4 | 5 | СистемнаяИнформация = Новый СистемнаяИнформация; 6 | ЭтоWindows = Найти(НРег(СистемнаяИнформация.ВерсияОС), "windows") > 0; 7 | 8 | ФС.ОбеспечитьПустойКаталог(ОбъединитьПути("build", "coverage")); 9 | ПутьКСтат = ОбъединитьПути("build", "coverage", "stat.json"); 10 | 11 | Команда = Новый Команда; 12 | Команда.УстановитьКоманду("oscript"); 13 | Если НЕ ЭтоWindows Тогда 14 | Команда.ДобавитьПараметр("-encoding=utf-8"); 15 | КонецЕсли; 16 | Команда.ДобавитьПараметр(СтрШаблон("-codestat=%1", ПутьКСтат)); 17 | Команда.ДобавитьПараметр(ОбъединитьПути("tasks", "test.os")); 18 | Команда.ПоказыватьВыводНемедленно(Истина); 19 | 20 | КодВозврата = Команда.Исполнить(); 21 | 22 | ПроцессорГенерации = Новый ГенераторОтчетаПокрытия(); 23 | 24 | ПроцессорГенерации.ОтносительныеПути() 25 | .РабочийКаталог(ОбъединитьПути("build", "coverage")) 26 | .КаталогИсходников(ТекущийКаталог()) 27 | .ИмяФайлаСтатистики() 28 | .GenericCoverage() 29 | .Cobertura() 30 | .Сформировать(); 31 | 32 | ЗавершитьРаботу(КодВозврата); 33 | -------------------------------------------------------------------------------- /.github/workflows/testing.yml: -------------------------------------------------------------------------------- 1 | # MIT License 2 | # Copyright (C) 2020 Tymko Oleg and contributors 3 | # All rights reserved. 4 | 5 | name: Тестирование 6 | # Любой пуш и pr в проекте 7 | on: [push, pull_request] 8 | 9 | jobs: 10 | build: 11 | runs-on: ${{ matrix.os }} 12 | strategy: 13 | fail-fast: false 14 | matrix: 15 | os: ['ubuntu-latest', 'macos-latest', 'windows-latest'] 16 | oscript_version: ['1.8.3', 'stable'] 17 | 18 | steps: 19 | # Загрузка проекта 20 | - name: Актуализация 21 | uses: actions/checkout@v2 22 | 23 | # Установка OneScript конкретной версии 24 | - name: Установка OneScript 25 | uses: otymko/setup-onescript@v1.1 26 | with: 27 | version: ${{ matrix.oscript_version }} 28 | 29 | # Установка зависимостей пакета 30 | - name: Установка зависимостей 31 | run: | 32 | opm install opm 33 | opm install -l --dev 34 | 35 | # Задача тестирования, в результате ожидается успешное выполнение 36 | - name: Тестирование 37 | run: oscript ./tasks/test.os 38 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2017 Nikita Gryzlov 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /tests/ОбработкаСтроки.os: -------------------------------------------------------------------------------- 1 | #Использовать asserts 2 | #Использовать ".." 3 | 4 | &Тест 5 | Процедура ТестДолжен_ПолучитьПроцессорКоллекцииИзЗаполненнойСтроки() Экспорт 6 | ПроцессорКоллекций = ПроцессорыКоллекций.ИзСтроки("123"); 7 | Результат = ПроцессорКоллекций.ВМассив(); 8 | Ожидаем.Что(Результат).ИмеетДлину(3); 9 | КонецПроцедуры 10 | 11 | &Тест 12 | Процедура ТестДолжен_ПолучитьПроцессорКоллекцииИзЗаполненнойСтрокиСРазделителем() Экспорт 13 | ПроцессорКоллекций = ПроцессорыКоллекций.ИзСтроки("1 2 3", " "); 14 | Результат = ПроцессорКоллекций.ВМассив(); 15 | Ожидаем.Что(Результат).ИмеетДлину(3); 16 | КонецПроцедуры 17 | 18 | &Тест 19 | Процедура ТестДолжен_ДолженВернутьСтрокуИзСтроки() Экспорт 20 | ПроцессорКоллекций = ПроцессорыКоллекций.ИзСтроки("1 2 3", " "); 21 | Результат = ПроцессорКоллекций.ВСтроку(); 22 | Ожидаем.Что(Результат).ИмеетДлину(3); 23 | КонецПроцедуры 24 | 25 | &Тест 26 | Процедура ТестДолжен_ДолженВернутьСтрокуСРазделителемИзСтроки() Экспорт 27 | ПроцессорКоллекций = ПроцессорыКоллекций.ИзСтроки("1 2 3", " "); 28 | Результат = ПроцессорКоллекций.ВСтроку(" "); 29 | Ожидаем.Что(Результат).ИмеетДлину(5); 30 | КонецПроцедуры 31 | -------------------------------------------------------------------------------- /tasks/test.os: -------------------------------------------------------------------------------- 1 | #Использовать 1testrunner 2 | #Использовать fs 3 | 4 | Функция ПрогнатьТесты() 5 | 6 | Тестер = Новый Тестер; 7 | Тестер.УстановитьФорматЛогФайла(Тестер.ФорматыЛогФайла().GenericExec); 8 | Тестер.ПодробныеОписанияОшибок(Истина); 9 | 10 | ПутьКТестам = "tests"; 11 | ПутьКОтчетуJUnit = ОбъединитьПути("build", "testsResults"); 12 | 13 | ФС.ОбеспечитьПустойКаталог(ПутьКОтчетуJUnit); 14 | 15 | РезультатТестирования = Тестер.ТестироватьКаталог( 16 | Новый Файл(ПутьКТестам), 17 | Новый Файл(ПутьКОтчетуJUnit) 18 | ); 19 | 20 | Успешно = РезультатТестирования = 0; 21 | 22 | Возврат Успешно; 23 | 24 | КонецФункции // ПрогнатьТесты() 25 | 26 | // основной код 27 | 28 | ТекКаталог = ТекущийКаталог(); 29 | 30 | Попытка 31 | ТестыПрошли = ПрогнатьТесты(); 32 | Исключение 33 | ТестыПрошли = Ложь; 34 | Сообщить(СтрШаблон("Тесты через 1testrunner выполнены неудачно 35 | |%1", ПодробноеПредставлениеОшибки(ИнформацияОбОшибке()))); 36 | КонецПопытки; 37 | 38 | УстановитьТекущийКаталог(ТекКаталог); 39 | 40 | Если Не ТестыПрошли Тогда 41 | ВызватьИсключение "Тестирование завершилось неудачно!"; 42 | Иначе 43 | Сообщить(СтрШаблон("Результат прогона тестов <%1> 44 | |", ТестыПрошли)); 45 | КонецЕсли; 46 | -------------------------------------------------------------------------------- /src/internal/Классы/ШагКонвейераРазвернуть.os: -------------------------------------------------------------------------------- 1 | #Использовать lambdas 2 | #Использовать asserts 3 | 4 | Перем Действие; 5 | 6 | Функция Принять(Коллекция) Экспорт 7 | 8 | Результат = Новый Массив; 9 | 10 | Для каждого Элемент Из Коллекция Цикл 11 | 12 | Процессор = Действие.Выполнить(Элемент); 13 | 14 | ДСО = СтрШаблон("Результат разворачивания для элемента %1 должен иметь тип ПроцессорКоллекций", Элемент); 15 | Ожидаем.Что(Процессор, ДСО).ИмеетТип("ПроцессорКоллекций"); 16 | 17 | Процессор.ДляКаждого( 18 | "Элемент -> Коллекция.Добавить(Элемент)", 19 | Новый Структура("Коллекция", Результат) 20 | ); 21 | 22 | КонецЦикла; 23 | 24 | Возврат Новый Структура("Действие, Коллекция", ДействияКонвейера.ЗаменитьКоллекцию, Результат); 25 | 26 | КонецФункции 27 | 28 | Функция Барьерный() Экспорт 29 | Возврат Истина; 30 | КонецФункции 31 | 32 | Процедура Деструктор() Экспорт 33 | 34 | ОсвободитьОбъект(Действие); 35 | 36 | Действие = Неопределено; 37 | 38 | КонецПроцедуры 39 | 40 | Процедура ПриСозданииОбъекта(ФункцияРазворачивания, ДополнительныеПараметры, Отладка) 41 | 42 | Действие = ПроцессорыКоллекцийСлужебный.ДействиеИзПараметров( 43 | ФункцияРазворачивания, 44 | ФункциональныеИнтерфейсы.УниФункция(), 45 | ДополнительныеПараметры, 46 | Отладка 47 | ); 48 | 49 | КонецПроцедуры 50 | -------------------------------------------------------------------------------- /src/internal/Классы/ШагКонвейераЛюбойСоответствует.os: -------------------------------------------------------------------------------- 1 | #Использовать lambdas 2 | 3 | Перем Действие; 4 | Перем ВозвращаемоеЗначение; 5 | 6 | Функция Принять(Элемент) Экспорт 7 | 8 | Если Действие.Выполнить(Элемент) Тогда 9 | Возврат Новый Структура("Действие, Значение", ДействияКонвейера.ВернутьЗначение, ВозвращаемоеЗначение); 10 | КонецЕсли; 11 | 12 | Возврат Новый Структура("Действие", ДействияКонвейера.Бездействие); 13 | 14 | КонецФункции 15 | 16 | Функция Барьерный() Экспорт 17 | Возврат Ложь; 18 | КонецФункции 19 | 20 | Процедура Деструктор() Экспорт 21 | 22 | ОсвободитьОбъект(Действие); 23 | 24 | Действие = Неопределено; 25 | 26 | КонецПроцедуры 27 | 28 | Процедура Инвертировать(ТолькоЗначение = Ложь) Экспорт 29 | 30 | Если Не ТолькоЗначение Тогда 31 | 32 | Действие = Лямбда.Выражение("Элемент -> Возврат Не Действие.Выполнить(Элемент)") 33 | .Контекст(Новый Структура("Действие", Действие)) 34 | .ВДействие(); 35 | 36 | КонецЕсли; 37 | 38 | ВозвращаемоеЗначение = Не ВозвращаемоеЗначение; 39 | 40 | КонецПроцедуры 41 | 42 | Процедура ПриСозданииОбъекта(ФункцияФильтрации, ДополнительныеПараметры, Отладка) 43 | 44 | Действие = ПроцессорыКоллекцийСлужебный.ДействиеИзПараметров( 45 | ФункцияФильтрации, 46 | ФункциональныеИнтерфейсы.УниФункция(), 47 | ДополнительныеПараметры, 48 | Отладка 49 | ); 50 | 51 | ВозвращаемоеЗначение = Истина; 52 | 53 | КонецПроцедуры 54 | -------------------------------------------------------------------------------- /src/internal/Классы/ШагКонвейераРазличные.os: -------------------------------------------------------------------------------- 1 | #Использовать lambdas 2 | 3 | Перем ДействиеРавенство; 4 | Перем ПринятыеЭлементы; 5 | 6 | Функция Принять(Элемент) Экспорт 7 | 8 | Для каждого ПринятыйЭлемент Из ПринятыеЭлементы Цикл 9 | 10 | Если ДействиеРавенство.Выполнить(ПринятыйЭлемент, Элемент) Тогда 11 | Возврат Новый Структура("Действие", ДействияКонвейера.ПропуститьЭлемент); 12 | КонецЕсли; 13 | 14 | КонецЦикла; 15 | 16 | ПринятыеЭлементы.Добавить(Элемент); 17 | 18 | Возврат Новый Структура("Действие", ДействияКонвейера.Бездействие); 19 | 20 | КонецФункции 21 | 22 | Функция Барьерный() Экспорт 23 | Возврат Ложь; 24 | КонецФункции 25 | 26 | Процедура Деструктор() Экспорт 27 | 28 | ОсвободитьОбъект(ПринятыеЭлементы); 29 | ОсвободитьОбъект(ДействиеРавенство); 30 | 31 | ПринятыеЭлементы = Неопределено; 32 | ДействиеРавенство = Неопределено; 33 | 34 | КонецПроцедуры 35 | 36 | Процедура ПриСозданииОбъекта(ФункцияРавенства, ДополнительныеПараметры, Отладка) 37 | 38 | ПринятыеЭлементы = Новый Массив(); 39 | 40 | Если ФункцияРавенства = Неопределено Тогда 41 | ДействиеРавенство = ПроцессорыКоллекций.СтандартнаяФункцияРавенства(); 42 | Иначе 43 | 44 | ДействиеРавенство = ПроцессорыКоллекцийСлужебный.ДействиеИзПараметров( 45 | ФункцияРавенства, 46 | ФункциональныеИнтерфейсы.БиФункция(), 47 | ДополнительныеПараметры, 48 | Отладка 49 | ); 50 | 51 | КонецЕсли; 52 | 53 | КонецПроцедуры 54 | -------------------------------------------------------------------------------- /.github/workflows/release.yml: -------------------------------------------------------------------------------- 1 | # MIT License 2 | # Copyright (C) 2020 Tymko Oleg and contributors 3 | # All rights reserved. 4 | 5 | name: Подготовка релиза и публикация в хабе 6 | # Только события создания и изменения релиза 7 | on: 8 | release: 9 | types: [published, edited] 10 | 11 | env: 12 | PACKAGE_MASK: fluent-*.ospx 13 | 14 | jobs: 15 | build: 16 | runs-on: ${{ matrix.os }} 17 | strategy: 18 | fail-fast: false 19 | matrix: 20 | os: [ubuntu-latest] 21 | oscript_version: ['stable'] 22 | 23 | steps: 24 | # Загрузка проекта 25 | - name: Актуализация 26 | uses: actions/checkout@v2 27 | 28 | # Установка OneScript конкретной версии 29 | - name: Установка OneScript 30 | uses: otymko/setup-onescript@v1.1 31 | with: 32 | version: ${{ matrix.oscript_version }} 33 | 34 | # Установка зависимостей пакета 35 | - name: Установка зависимостей 36 | run: | 37 | opm install opm 38 | opm install 39 | 40 | - name: Сборка пакета 41 | run: opm build . 42 | 43 | - name: Заливка артефактов 44 | uses: actions/upload-artifact@v2 45 | with: 46 | name: package.zip 47 | path: ./${{ env.PACKAGE_MASK }} 48 | 49 | #- name: Заливка в релиз 50 | # uses: AButler/upload-release-assets@v2.0.2 51 | # with: 52 | # files: ./${{ env.PACKAGE_MASK }} 53 | # repo-token: ${{ secrets.GITHUB_TOKEN }} 54 | 55 | - name: Публикация в hub.oscript.io 56 | shell: bash 57 | run: opm push -f ./${{ env.PACKAGE_MASK }} --token ${{ secrets.PUSH_TOKEN }} -c stable 58 | -------------------------------------------------------------------------------- /src/internal/Классы/ШагКонвейераПолучить.os: -------------------------------------------------------------------------------- 1 | Перем ТипРезультата; 2 | Перем КэшКолонок; 3 | 4 | Функция Принять(Коллекция) Экспорт 5 | 6 | Результат = Новый(ТипРезультата); 7 | 8 | РезультатСодержитКолонки = Истина; 9 | Попытка 10 | Колонки = Результат.Колонки; 11 | Исключение 12 | РезультатСодержитКолонки = Ложь; 13 | КонецПопытки; 14 | 15 | Если РезультатСодержитКолонки Тогда 16 | 17 | Для Каждого Колонка Из КэшКолонок Цикл 18 | Результат.Колонки.Добавить( 19 | Колонка.Имя, 20 | Колонка.ТипЗначения, 21 | Колонка.Заголовок, 22 | Колонка.Ширина 23 | ); 24 | КонецЦикла; 25 | 26 | Если Результат.Колонки.Количество() = 0 Тогда 27 | Результат.Колонки.Добавить("Значение"); 28 | КонецЕсли; 29 | 30 | КонецЕсли; 31 | 32 | ЭлементСодержитКолонки = КэшКолонок.Количество() > 0; 33 | 34 | Для Каждого ЭлементКоллекции Из Коллекция Цикл 35 | 36 | Если РезультатСодержитКолонки И ЭлементСодержитКолонки Тогда 37 | ЗаполнитьЗначенияСвойств(Результат.Добавить(), ЭлементКоллекции); 38 | ИначеЕсли РезультатСодержитКолонки Тогда 39 | НоваяСтрока = Результат.Добавить(); 40 | НоваяСтрока.Значение = ЭлементКоллекции; 41 | Иначе 42 | Результат.Добавить(ЭлементКоллекции); 43 | КонецЕсли; 44 | 45 | КонецЦикла; 46 | 47 | Возврат Новый Структура("Действие, Значение", ДействияКонвейера.ВернутьЗначение, Результат); 48 | 49 | КонецФункции 50 | 51 | Функция Барьерный() Экспорт 52 | Возврат Истина; 53 | КонецФункции 54 | 55 | Процедура Деструктор() Экспорт 56 | КэшКолонок = Неопределено; 57 | КонецПроцедуры 58 | 59 | Процедура ПриСозданииОбъекта(пТипРезультата, пКэшКолонок = Неопределено) 60 | 61 | ТипРезультата = пТипРезультата; 62 | 63 | Если пКэшКолонок = Неопределено Тогда 64 | КэшКолонок = Новый Массив; 65 | Иначе 66 | КэшКолонок = пКэшКолонок; 67 | КонецЕсли; 68 | 69 | КонецПроцедуры 70 | -------------------------------------------------------------------------------- /CHANGELOG.md: -------------------------------------------------------------------------------- 1 | ## 0.6.0 2 | * Добавлена поддержка Действие для функционального интерфейса 3 | * Добавлена поддержка лямбда выражений библиотеки lambdas 4 | * Ядро переписано с `notify` на собственную абстракцию `ШагКонвейера` 5 | * Шаги конвейера разделены на барьерные и не барьерные операции 6 | 7 | > DEPRECATION NOTICE: 8 | 9 | * Отказ от использования notify, в пользу Действие 10 | * Синтаксис лямбда выражений заменён на использование lambdas 11 | * ОписаниеОповещений и старый синтаксис лямбда выражений поддерживаются в рамках обратной совместимости, однако при их использовании будут предупреждения в логе, пожалуйста замените все места использования устаревшей функциональности 12 | 13 | ## 0.5.0 14 | 15 | * Добавлена возможность отладки временных сценариев путем создания временных файлов под текст сценария. 16 | 17 | ## 0.4.0 18 | 19 | * Добавлен конвейерный метод Развернуть/flatMap 20 | * Добавлено создание процессора коллекций из набора параметров (varargs...) 21 | 22 | ## 0.3.1 23 | 24 | * Реальный переезд на использование API `Новый ОписаниеОповещения()` 25 | 26 | ## 0.3.0 27 | 28 | * Обновление `notify` до версии `0.2.0` 29 | * Отказ от создания временных файлов в пользу создания описания оповещения через `ЗагрузитьСценарийИзСтроки` 30 | * Переезд на движок версии `1.0.18` 31 | 32 | ## 0.2.2 33 | 34 | * Исправлена ошибка неудаления временных файлов при вызове некоторых терминальных методов 35 | 36 | ## 0.2.1 37 | 38 | * Оптимизация создания временного описания оповещения 39 | 40 | ## 0.2.0 41 | 42 | * В метод `ВСтроку` добавлен параметр `РазделительСтрок` для управлением конкатенацией 43 | * Более аккуратная работа с памятью при использовании временных описаний оповещений 44 | * Переименование: `СтандартныйОбработчик_Сообщить` -> `СтандартнаяФункцияОбработки_Сообщить` 45 | * Переименование: `СтандартныйОбработчикСравнения` -> `СтандартнаяФункцияСравнения` 46 | * Зависимость от движка снижена до 1.0.15.211 47 | * Добавлены тесты :) 48 | * Добавлено README и CHANGELOG 49 | 50 | ## 0.1.1 51 | 52 | * Возможность использовать сокращенный вариант обращения к параметрам обработчиков -> `Элемент` вместо `ДополнительныеПараметры.Элемент` 53 | 54 | ## 0.1.0 55 | 56 | * Первый релиз 57 | -------------------------------------------------------------------------------- /src/internal/Классы/ШагКонвейераСортировать.os: -------------------------------------------------------------------------------- 1 | #Использовать lambdas 2 | #Использовать asserts 3 | 4 | Перем Действие; 5 | Перем ПолеСортировки; 6 | 7 | Функция Принять(Коллекция) Экспорт 8 | 9 | Результат = Коллекция; 10 | 11 | Для й = 0 По Результат.ВГраница() Цикл 12 | Флаг = Ложь; 13 | к = Результат.ВГраница(); 14 | Пока к > й Цикл 15 | 16 | Элемент = Результат[к - 1]; 17 | СледующийЭлемент = Результат[к]; 18 | 19 | Если ПустаяСтрока(ПолеСортировки) Тогда 20 | РезультатСортировки = Действие.Выполнить(Элемент, СледующийЭлемент); 21 | Иначе 22 | РезультатСортировки = Действие.Выполнить(Элемент[ПолеСортировки], СледующийЭлемент[ПолеСортировки]); 23 | КонецЕсли; 24 | 25 | Если РезультатСортировки > 0 Тогда 26 | Результат[к - 1] = СледующийЭлемент; 27 | Результат[к] = Элемент; 28 | Флаг = Истина; 29 | КонецЕсли; 30 | к = к - 1; 31 | КонецЦикла; 32 | Если НЕ Флаг Тогда 33 | Прервать; 34 | КонецЕсли; 35 | КонецЦикла; 36 | 37 | Возврат Новый Структура("Действие, Коллекция", ДействияКонвейера.ЗаменитьКоллекцию, Результат); 38 | 39 | КонецФункции 40 | 41 | Функция Барьерный() Экспорт 42 | Возврат Истина; 43 | КонецФункции 44 | 45 | Процедура Деструктор() Экспорт 46 | 47 | ОсвободитьОбъект(Действие); 48 | 49 | Действие = Неопределено; 50 | 51 | КонецПроцедуры 52 | 53 | Процедура Инвертировать() Экспорт 54 | 55 | Если Действие = ПроцессорыКоллекций.СтандартнаяФункцияСравненияПрямойПорядок() Тогда 56 | Действие = ПроцессорыКоллекций.СтандартнаяФункцияСравненияОбратныйПорядок(); 57 | Иначе 58 | 59 | Действие = Лямбда.Выражение("Первый, Второй -> Возврат -Действие.Выполнить(Первый, Второй)") 60 | .Контекст(Новый Структура("Действие", Действие)) 61 | .ВДействие(); 62 | 63 | КонецЕсли; 64 | 65 | КонецПроцедуры 66 | 67 | Процедура ПриСозданииОбъекта(ФункцияРазворачивания, ДополнительныеПараметры, Отладка, Поле = "") 68 | 69 | Если ФункцияРазворачивания = Неопределено Тогда 70 | Действие = ПроцессорыКоллекций.СтандартнаяФункцияСравненияПрямойПорядок(); 71 | Иначе 72 | 73 | Действие = ПроцессорыКоллекцийСлужебный.ДействиеИзПараметров( 74 | ФункцияРазворачивания, 75 | ФункциональныеИнтерфейсы.БиФункция(), 76 | ДополнительныеПараметры, 77 | Отладка 78 | ); 79 | 80 | КонецЕсли; 81 | 82 | ПолеСортировки = Поле; 83 | 84 | КонецПроцедуры 85 | -------------------------------------------------------------------------------- /examples/test.os: -------------------------------------------------------------------------------- 1 | #Использовать ".." 2 | 3 | Функция ОбработчикФильтрации(Элемент) Экспорт 4 | Возврат Элемент > 3; 5 | КонецФункции 6 | 7 | Функция ОбработчикОбработки(Элемент) Экспорт 8 | Результат = Элемент + 1; 9 | Сообщить("Я - операция map, и это мое послание миру: элемент " + Элемент + " превратился в " + Результат); 10 | Возврат Результат; 11 | КонецФункции 12 | 13 | Функция ОбработчикСокращения(Результат, Элемент) Экспорт 14 | Возврат Результат + Элемент; 15 | КонецФункции 16 | 17 | ФункцияФильтрации = Новый Действие(ЭтотОбъект, "ОбработчикФильтрации"); 18 | ФункцияОбработки = Новый Действие(ЭтотОбъект, "ОбработчикОбработки"); 19 | ФункцияСокращения = Новый Действие(ЭтотОбъект, "ОбработчикСокращения"); 20 | 21 | Массив = Новый Массив; 22 | Массив.Добавить(3); 23 | Массив.Добавить(4); 24 | Массив.Добавить(7); 25 | Массив.Добавить(5); 26 | Массив.Добавить(1); 27 | Массив.Добавить(0); 28 | 29 | ПроцессорКоллекций = Новый ПроцессорКоллекций; 30 | ПроцессорКоллекций.УстановитьКоллекцию(Массив); 31 | 32 | Результат = ПроцессорКоллекций 33 | .Пропустить(2) 34 | .Фильтровать(ФункцияФильтрации) 35 | .Первые(2) 36 | .Обработать(ФункцияОбработки) 37 | .Получить(Тип("Массив")); 38 | 39 | Для Каждого Элемент Из Результат Цикл 40 | Сообщить(Элемент); 41 | КонецЦикла; 42 | 43 | ПроцессорКоллекций = ПроцессорыКоллекций.ИзКоллекции(Массив); 44 | ПроцессорКоллекций 45 | .Сортировать() 46 | .ДляКаждого("Элемент -> Сообщить(Элемент)"); 47 | 48 | Массив = Новый Массив; 49 | Массив.Добавить(4); 50 | Массив.Добавить(2); 51 | Массив.Добавить(2); 52 | Массив.Добавить(3); 53 | Массив.Добавить(3); 54 | Массив.Добавить(3); 55 | 56 | ПроцессорКоллекций = ПроцессорыКоллекций.ИзКоллекции(Массив); 57 | ПроцессорКоллекций 58 | .Различные() 59 | .ДляКаждого("Элемент -> Сообщить(Элемент)"); 60 | 61 | ПроцессорКоллекций = ПроцессорыКоллекций.ИзКоллекции(Массив); 62 | Результат = ПроцессорКоллекций 63 | .Обработать(ФункцияОбработки) 64 | .Сократить(ФункцияСокращения, 0); 65 | 66 | Сообщить(Результат); 67 | 68 | // Результат должен различаться 69 | ПроцессорыКоллекций 70 | .ИзКоллекции(Массив) 71 | .Сортировать() 72 | .Первые(1) 73 | .ДляКаждого("Элемент -> Сообщить(Элемент)"); 74 | Сообщить(Массив[0]); 75 | 76 | Строка = "ФЫВА"; 77 | ПроцессорыКоллекций 78 | .ИзСтроки(Строка) 79 | .Сортировать() 80 | .ДляКаждого("Элемент -> Сообщить(Элемент)"); 81 | 82 | Строка = "Я строка с пробелами"; 83 | ПроцессорыКоллекций 84 | .ИзСтроки(Строка, " ") 85 | .ДляКаждого("Элемент -> Сообщить(Элемент)"); 86 | 87 | Строка = "Я 88 | |строка 89 | |многострочная"; 90 | 91 | ПроцессорыКоллекций 92 | .ИзСтроки(Строка, Символы.ПС) 93 | .Сортировать() 94 | .ДляКаждого("Элемент -> Сообщить(Элемент)"); 95 | 96 | ПроцессорыКоллекций 97 | .ИзСтроки(Строка, Символы.ПС) 98 | .Фильтровать("Элемент -> СтрДлина(Элемент) > 1") 99 | .ДляКаждого("Элемент -> Сообщить(Элемент)"); 100 | -------------------------------------------------------------------------------- /.github/workflows/qa.yml: -------------------------------------------------------------------------------- 1 | # MIT License 2 | # Copyright (C) 2020 Tymko Oleg and contributors 3 | # All rights reserved. 4 | 5 | name: Контроль качества 6 | # Любой пуш и pr в проекте но с фильтром по основному проекту 7 | on: [push, pull_request] 8 | jobs: 9 | build: 10 | if: (github.repository == 'nixel2007/oscript-fluent') && (github.event_name == 'push' || github.event.pull_request.head.repo.full_name == github.event.repository.full_name) 11 | runs-on: ${{ matrix.os }} 12 | strategy: 13 | fail-fast: false 14 | matrix: 15 | os: [ubuntu-latest] 16 | oscript_version: ['stable'] 17 | 18 | steps: 19 | # Загрузка проекта 20 | - name: Актуализация 21 | uses: actions/checkout@v2 22 | 23 | # Вычисление имени ветки 24 | - name: Compute branch name 25 | uses: nelonoel/branch-name@v1.0.1 26 | 27 | # Установка OneScript конкретной версии 28 | - name: Установка OneScript 29 | uses: otymko/setup-onescript@v1.1 30 | with: 31 | version: ${{ matrix.oscript_version }} 32 | 33 | # Установка зависимостей пакета 34 | - name: Установка зависимостей 35 | run: | 36 | opm install opm 37 | opm install -l --dev 38 | 39 | # Запуск тестов и сбор покрытия кода 40 | - name: Покрытие кода 41 | run: oscript ./tasks/coverage.os 42 | 43 | - name: Извлечение версии пакета 44 | shell: bash 45 | run: echo "##[set-output name=version;]`cat packagedef | grep ".Версия(" | sed 's|[^"]*"||' | sed -r 's/".+//'`" 46 | id: extract_version 47 | 48 | - name: Setup sonarqube 49 | uses: warchant/setup-sonar-scanner@v3 50 | 51 | # Анализ проекта в SonarQube (ветка) 52 | - name: Анализ в SonarQube (branch) 53 | if: github.event_name == 'push' 54 | env: 55 | GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} 56 | SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }} 57 | run: sonar-scanner 58 | -Dsonar.host.url=https://sonar.openbsl.ru 59 | -Dsonar.branch.name=${{ env.BRANCH_NAME }} 60 | -Dsonar.projectVersion=${{ steps.extract_version.outputs.version }} 61 | 62 | # Анализ проекта в SonarQube (PR) 63 | # https://docs.sonarqube.org/latest/analysis/pull-request/ 64 | - name: Анализ в SonarQube (pull-request) 65 | if: github.event_name == 'pull_request' 66 | env: 67 | GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} 68 | SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }} 69 | run: sonar-scanner 70 | -Dsonar.host.url=https://sonar.openbsl.ru 71 | -Dsonar.pullrequest.key=${{ github.event.pull_request.number }} 72 | -Dsonar.pullrequest.branch=${{ github.event.pull_request.head.ref }} 73 | -Dsonar.pullrequest.base=${{ github.event.pull_request.base.ref }} 74 | -Dsonar.scm.revision=${{ github.event.pull_request.head.sha }} 75 | -------------------------------------------------------------------------------- /examples/github.os: -------------------------------------------------------------------------------- 1 | #Использовать ".." 2 | 3 | Перем Таблица; 4 | 5 | Процедура ДобавитьСтрокуВТаблицу(Имя, Фолловеры, Местоположение, Контрибьюции) 6 | 7 | Строка = Таблица.Добавить(); 8 | 9 | Строка.Имя = Имя; 10 | Строка.Фолловеры = Фолловеры; 11 | Строка.Местоположение = Местоположение; 12 | Строка.Контрибьюции = Контрибьюции; 13 | 14 | КонецПроцедуры 15 | 16 | Функция Обработчик_ФильтрацияПоМестоположению(Элемент) Экспорт 17 | Возврат Элемент.Местоположение = "Россия"; 18 | КонецФункции 19 | 20 | Функция Обработчик_СортировкаПоФолловерам(Первый, Второй) Экспорт 21 | 22 | Если Первый.Фолловеры > Второй.Фолловеры Тогда 23 | Возврат 1; 24 | ИначеЕсли Второй.Фолловеры > Первый.Фолловеры Тогда 25 | Возврат -1; 26 | Иначе 27 | Возврат 0; 28 | КонецЕсли; 29 | 30 | КонецФункции 31 | 32 | Функция Обработчик_СортировкаПоКонтрибьюциям(Первый, Второй) Экспорт 33 | 34 | Если Первый.Контрибьюции > Второй.Контрибьюции Тогда 35 | Возврат 1; 36 | ИначеЕсли Второй.Контрибьюции > Первый.Контрибьюции Тогда 37 | Возврат -1; 38 | Иначе 39 | Возврат 0; 40 | КонецЕсли; 41 | 42 | КонецФункции 43 | 44 | ФильтрацияПоМестоположению = Новый Действие(ЭтотОбъект, "Обработчик_ФильтрацияПоМестоположению"); 45 | СортировкаПоФолловерам = Новый Действие(ЭтотОбъект, "Обработчик_СортировкаПоФолловерам"); 46 | СортировкаПоКонтрибьюциям = Новый Действие(ЭтотОбъект, "Обработчик_СортировкаПоКонтрибьюциям"); 47 | 48 | Таблица = Новый ТаблицаЗначений; 49 | Таблица.Колонки.Добавить("Имя"); 50 | Таблица.Колонки.Добавить("Фолловеры"); 51 | Таблица.Колонки.Добавить("Местоположение"); 52 | Таблица.Колонки.Добавить("Контрибьюции"); 53 | 54 | ДобавитьСтрокуВТаблицу("Иванов", 10, "Новая Зеландия", 45); 55 | ДобавитьСтрокуВТаблицу("Петров", 0, "Россия", 50); 56 | ДобавитьСтрокуВТаблицу("Сидоров", 15, "Россия", 12); 57 | ДобавитьСтрокуВТаблицу("Туполев", 99, "Россия", 44); 58 | ДобавитьСтрокуВТаблицу("Миль", 23, "Нидерланды", 31); 59 | ДобавитьСтрокуВТаблицу("Сухой", 3, "Россия", 123); 60 | ДобавитьСтрокуВТаблицу("Лавочкин", 10, "Россия", 68); 61 | ДобавитьСтрокуВТаблицу("Яковлев", 12, "Россия", 99); 62 | 63 | ПроцессорКоллекций = ПроцессорыКоллекций.ИзКоллекции(Таблица); 64 | Результат = ПроцессорКоллекций 65 | .Фильтровать(ФильтрацияПоМестоположению) 66 | .Сортировать(СортировкаПоФолловерам) 67 | .Первые(5) 68 | .Сортировать(СортировкаПоКонтрибьюциям) 69 | .Первые(3) 70 | .Получить(Тип("ТаблицаЗначений")); 71 | 72 | Для Каждого Элемент Из Результат Цикл 73 | Сообщить(Элемент.Имя); 74 | КонецЦикла; 75 | 76 | ПроцессорыКоллекций.ИзКоллекции(Таблица) 77 | .Фильтровать("Элемент -> Элемент.Местоположение = ""Россия""") 78 | .Сортировать("Первый, Второй -> 79 | | Если Первый.Фолловеры > Второй.Фолловеры Тогда 80 | | Возврат 1; 81 | | ИначеЕсли Второй.Фолловеры > Первый.Фолловеры Тогда 82 | | Возврат -1; 83 | | Иначе 84 | | Возврат 0; 85 | | КонецЕсли;" 86 | ) 87 | .Первые(5) 88 | .Сортировать("Первый, Второй -> 89 | | Если Первый.Контрибьюции > Второй.Контрибьюции Тогда 90 | | Возврат 1; 91 | | ИначеЕсли Второй.Контрибьюции > Первый.Контрибьюции Тогда 92 | | Возврат -1; 93 | | Иначе 94 | | Возврат 0; 95 | | КонецЕсли;" 96 | ) 97 | .Первые(3) 98 | .ДляКаждого("Элемент -> Сообщить(Элемент.Имя)"); 99 | 100 | // githubUsers 101 | // .filter(_.location == 'Russia') 102 | // .sort(_.followers) 103 | // .take(1000) 104 | // .sort(_.contributions) 105 | // .take(256) 106 | -------------------------------------------------------------------------------- /tests/КонвейерныеМетоды.os: -------------------------------------------------------------------------------- 1 | #Использовать asserts 2 | #Использовать ".." 3 | 4 | Функция ПолучитьИсходныйМассив() 5 | 6 | Массив = Новый Массив; 7 | Массив.Добавить(2); 8 | Массив.Добавить(1); 9 | Массив.Добавить(4); 10 | Массив.Добавить(1); 11 | Массив.Добавить(0); 12 | Массив.Добавить(3); 13 | 14 | Возврат Массив; 15 | 16 | КонецФункции 17 | 18 | Функция ПолучитьДлинуИсходногоМассива() 19 | Возврат ПолучитьИсходныйМассив().Количество(); 20 | КонецФункции 21 | 22 | Функция ПолучитьПроцессорКоллекций() 23 | Массив = ПолучитьИсходныйМассив(); 24 | Возврат ПроцессорыКоллекций.ИзКоллекции(Массив); 25 | КонецФункции 26 | 27 | &Тест 28 | Процедура ТестДолжен_ПолучитьИзПроцессораКоллекцийМассив() Экспорт 29 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 30 | Результат = ПроцессорКоллекций.ВМассив(); 31 | Ожидаем.Что(Результат).ИмеетТип("Массив").ИмеетДлину(ПолучитьДлинуИсходногоМассива()); 32 | КонецПроцедуры 33 | 34 | &Тест 35 | Процедура ТестДолжен_ПолучитьПервыеНесколькоЭлементов() Экспорт 36 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 37 | Результат = ПроцессорКоллекций.Первые(2).ВМассив(); 38 | Ожидаем.Что(Результат).ИмеетДлину(2); 39 | Ожидаем.Что(Результат[0]).Равно(2); 40 | Ожидаем.Что(Результат[1]).Равно(1); 41 | КонецПроцедуры 42 | 43 | &Тест 44 | Процедура ТестДолжен_ПропуститьНесколькоЭлементов() Экспорт 45 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 46 | Результат = ПроцессорКоллекций.Пропустить(3).ВМассив(); 47 | Ожидаем.Что(Результат).ИмеетДлину(ПолучитьДлинуИсходногоМассива() - 3); 48 | Ожидаем.Что(Результат[0]).Равно(1); 49 | КонецПроцедуры 50 | 51 | &Тест 52 | Процедура ТестДолжен_ПолучитьРазличныеЭлементы() Экспорт 53 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 54 | Результат = ПроцессорКоллекций.Различные().ВМассив(); 55 | Ожидаем.Что(Результат).ИмеетДлину(5); 56 | 57 | Ожидаем.Что(Результат[0]).Равно(2); 58 | Ожидаем.Что(Результат[1]).Равно(1); 59 | Ожидаем.Что(Результат[2]).Равно(4); 60 | Ожидаем.Что(Результат[3]).Равно(0); 61 | Ожидаем.Что(Результат[4]).Равно(3); 62 | КонецПроцедуры 63 | 64 | &Тест 65 | Процедура ТестДолжен_ПолучитьУвеличитьВсеЭлементыНаЕдиницуЧерезОбработку() Экспорт 66 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 67 | Результат = ПроцессорКоллекций.Обработать("Результат = Элемент + 1").ВМассив(); 68 | ИсходныйМассив = ПолучитьИсходныйМассив(); 69 | Для сч = 0 По ИсходныйМассив.ВГраница() Цикл 70 | Ожидаем.Что(Результат[сч]).Равно(ИсходныйМассив[сч] + 1); 71 | КонецЦикла; 72 | КонецПроцедуры 73 | 74 | &Тест 75 | Процедура ТестДолжен_ПолучитьУвеличитьВсеЭлементыНаЕдиницуЧерезОбработку_Лямбда() Экспорт 76 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 77 | Результат = ПроцессорКоллекций.Обработать("Элемент -> Элемент + 1").ВМассив(); 78 | ИсходныйМассив = ПолучитьИсходныйМассив(); 79 | Для сч = 0 По ИсходныйМассив.ВГраница() Цикл 80 | Ожидаем.Что(Результат[сч]).Равно(ИсходныйМассив[сч] + 1); 81 | КонецЦикла; 82 | КонецПроцедуры 83 | 84 | &Тест 85 | Процедура ТестДолжен_СобратьДваПроцессораВОдин() Экспорт 86 | 87 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 88 | Результат = ПроцессорКоллекций.Развернуть( 89 | "Массив = Новый Массив; 90 | |Массив.Добавить(Элемент); 91 | |Массив.Добавить(Элемент + 1); 92 | |Результат = ПроцессорыКоллекций.ИзКоллекции(Массив)" 93 | ).Фильтровать("Результат = Элемент = 2") 94 | .Количество(); 95 | 96 | Ожидаем.Что(Результат, "Процессоры коллекций должны сложиться и отфильтроваться").Равно(3); 97 | 98 | КонецПроцедуры 99 | 100 | &Тест 101 | Процедура ТестДолжен_СобратьДваПроцессораВОдин_Лямбда() Экспорт 102 | 103 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 104 | Результат = ПроцессорКоллекций.Развернуть("Элемент -> 105 | | Массив = Новый Массив; 106 | | Массив.Добавить(Элемент); 107 | | Массив.Добавить(Элемент + 1); 108 | | Возврат ПроцессорыКоллекций.ИзКоллекции(Массив);" 109 | ).Фильтровать("Элемент -> Элемент = 2") 110 | .Количество(); 111 | 112 | Ожидаем.Что(Результат, "Процессоры коллекций должны сложиться и отфильтроваться").Равно(3); 113 | 114 | КонецПроцедуры 115 | 116 | &Тест 117 | Процедура ТестДолжен_ОтфильтроватьЭлементыМеньшеДвух() Экспорт 118 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 119 | Результат = ПроцессорКоллекций.Фильтровать("Результат = Элемент < 2").ВМассив(); 120 | Для Каждого Элемент Из Результат Цикл 121 | Ожидаем.Что(Элемент).Меньше(2); 122 | КонецЦикла; 123 | КонецПроцедуры 124 | 125 | &Тест 126 | Процедура ТестДолжен_ОтфильтроватьЭлементыМеньшеДвух_Лямбда() Экспорт 127 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 128 | Результат = ПроцессорКоллекций.Фильтровать("Элемент -> Элемент < 2").ВМассив(); 129 | Для Каждого Элемент Из Результат Цикл 130 | Ожидаем.Что(Элемент).Меньше(2); 131 | КонецЦикла; 132 | КонецПроцедуры 133 | 134 | &Тест 135 | Процедура ТестДолжен_ОтсортироватьЭлементы() Экспорт 136 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 137 | Результат = ПроцессорКоллекций.Сортировать().ВМассив(); 138 | ПредыдущийЭлемент = -1; 139 | Для Каждого Элемент Из Результат Цикл 140 | Ожидаем.Что(Элемент).БольшеИлиРавно(ПредыдущийЭлемент); 141 | ПредыдущийЭлемент = Макс(Элемент, ПредыдущийЭлемент); 142 | КонецЦикла; 143 | КонецПроцедуры 144 | 145 | &Тест 146 | Процедура ТестДолжен_ОтсортироватьТаблицуПоКолонке() Экспорт 147 | Таблица = Новый ТаблицаЗначений(); 148 | Таблица.Колонки.Добавить("НомерСтроки", Новый ОписаниеТипов("Число")); 149 | 150 | Таблица.Добавить().НомерСтроки = 2; 151 | Таблица.Добавить().НомерСтроки = 3; 152 | Таблица.Добавить().НомерСтроки = 1; 153 | 154 | ПроцессорКоллекций = ПроцессорыКоллекций.ИзКоллекции(Таблица); 155 | Результат = ПроцессорКоллекций.СортироватьПо("НомерСтроки").ВМассив(); 156 | 157 | Для сч = 0 По Таблица.Количество() - 1 Цикл 158 | Ожидаем.Что(Таблица[сч].НомерСтроки = сч); 159 | КонецЦикла; 160 | КонецПроцедуры 161 | -------------------------------------------------------------------------------- /tests/ИнтеграционныйТест.os: -------------------------------------------------------------------------------- 1 | #Использовать asserts 2 | #Использовать notify 3 | #Использовать ".." 4 | 5 | Перем ФункцияОбработки; 6 | Перем ФункцияСокращения; 7 | Перем ФункцияФильтрации; 8 | 9 | Перем ДействиеОбработки; 10 | Перем ДействиеСокращения; 11 | Перем ДействиеФильтрации; 12 | 13 | Процедура ОбработчикФильтрации(Результат, ДополнительныеПараметры) Экспорт 14 | Элемент = ДополнительныеПараметры.Элемент; 15 | Результат = Элемент > 3; 16 | КонецПроцедуры 17 | 18 | Процедура ОбработчикОбработки(Результат, ДополнительныеПараметры) Экспорт 19 | Элемент = ДополнительныеПараметры.Элемент; 20 | Результат = Элемент + 1; 21 | КонецПроцедуры 22 | 23 | Процедура ОбработчикСокращения(Результат, ДополнительныеПараметры) Экспорт 24 | Элемент = ДополнительныеПараметры.Элемент; 25 | Результат = Результат + Элемент; 26 | КонецПроцедуры 27 | 28 | Функция ДействиеФильтрации(Элемент) Экспорт 29 | Возврат Элемент > 3; 30 | КонецФункции 31 | 32 | Функция ДействиеОбработки(Элемент) Экспорт 33 | Возврат Элемент + 1; 34 | КонецФункции 35 | 36 | Функция ДействиеСокращения(Результат, Элемент) Экспорт 37 | Возврат Результат + Элемент; 38 | КонецФункции 39 | 40 | Функция ПолучитьНачальныйМассив() 41 | 42 | Массив = Новый Массив; 43 | Массив.Добавить(3); 44 | Массив.Добавить(4); 45 | Массив.Добавить(7); 46 | Массив.Добавить(5); 47 | Массив.Добавить(1); 48 | Массив.Добавить(0); 49 | 50 | Возврат Массив; 51 | КонецФункции 52 | 53 | Функция ПолучитьПроцессорКоллекций() 54 | 55 | Возврат ПроцессорыКоллекций.ИзКоллекции(ПолучитьНачальныйМассив()); 56 | 57 | КонецФункции 58 | 59 | &Тест 60 | Процедура ТестДолжен_1() Экспорт 61 | 62 | Результат = ПолучитьПроцессорКоллекций() 63 | .Пропустить(2) 64 | .Фильтровать(ФункцияФильтрации) 65 | .Первые(2) 66 | .Обработать(ФункцияОбработки) 67 | .Получить(Тип("Массив")); 68 | 69 | Ожидаем.Что(Результат[0]).Равно(8); 70 | Ожидаем.Что(Результат[1]).Равно(6); 71 | 72 | КонецПроцедуры 73 | 74 | &Тест 75 | Процедура ТестДолжен_1_1() Экспорт 76 | 77 | Результат = ПолучитьПроцессорКоллекций() 78 | .Пропустить(2) 79 | .Фильтровать(ДействиеФильтрации) 80 | .Первые(2) 81 | .Обработать(ДействиеОбработки) 82 | .Получить(Тип("Массив")); 83 | 84 | Ожидаем.Что(Результат[0]).Равно(8); 85 | Ожидаем.Что(Результат[1]).Равно(6); 86 | 87 | КонецПроцедуры 88 | 89 | &Тест 90 | Процедура ТестДолжен_2() Экспорт 91 | 92 | Результат = ПолучитьПроцессорКоллекций() 93 | .Сортировать() 94 | .ВМассив(); 95 | 96 | Ожидаем.Что(Результат[0]).Равно(0); 97 | Ожидаем.Что(Результат[1]).Равно(1); 98 | Ожидаем.Что(Результат[2]).Равно(3); 99 | Ожидаем.Что(Результат[3]).Равно(4); 100 | Ожидаем.Что(Результат[4]).Равно(5); 101 | Ожидаем.Что(Результат[5]).Равно(7); 102 | 103 | КонецПроцедуры 104 | 105 | &Тест 106 | Процедура ТестДолжен_3() Экспорт 107 | 108 | Результат = ПолучитьПроцессорКоллекций() 109 | .Обработать(ФункцияОбработки) 110 | .Сократить(ФункцияСокращения, 0); 111 | 112 | Ожидаем.Что(Результат).Равно(26); 113 | 114 | КонецПроцедуры 115 | 116 | &Тест 117 | Процедура ТестДолжен_3_1() Экспорт 118 | 119 | Результат = ПолучитьПроцессорКоллекций() 120 | .Обработать(ДействиеОбработки) 121 | .Сократить(ДействиеСокращения, 0); 122 | 123 | Ожидаем.Что(Результат).Равно(26); 124 | 125 | КонецПроцедуры 126 | 127 | &Тест 128 | Процедура ТестДолжен_4() Экспорт 129 | 130 | // Результат должен различаться 131 | Результат = ПолучитьПроцессорКоллекций() 132 | .Сортировать() 133 | .Первые(1) 134 | .Получить("Массив"); 135 | 136 | Ожидаем.Что(Результат[0]).Равно(0); 137 | Ожидаем.Что(ПолучитьНачальныйМассив()[0]).Равно(3); 138 | 139 | КонецПроцедуры 140 | 141 | &Тест 142 | Процедура ТестДолжен_5() Экспорт 143 | 144 | Строка = "ФЫВА"; 145 | Результат = ПроцессорыКоллекций.ИзСтроки(Строка) 146 | .Сортировать() 147 | .ВСтроку(); 148 | 149 | Ожидаем.Что(Результат).Равно("АВФЫ"); 150 | 151 | КонецПроцедуры 152 | 153 | &Тест 154 | Процедура ТестДолжен_6() Экспорт 155 | 156 | Строка = "Я строка с пробелами"; 157 | Результат = ПроцессорыКоллекций.ИзСтроки(Строка, " ") 158 | .ВСтроку(); 159 | 160 | Ожидаем.Что(Результат).Равно("Ястрокаспробелами"); 161 | 162 | КонецПроцедуры 163 | 164 | &Тест 165 | Процедура ТестДолжен_7() Экспорт 166 | 167 | Строка = 168 | "Я 169 | |строка 170 | |многострочная"; 171 | 172 | Результат = ПроцессорыКоллекций.ИзСтроки(Строка, Символы.ПС) 173 | .Сортировать() 174 | .ВСтроку(Символы.ПС); 175 | 176 | Ожидаем.Что(Результат).Равно( 177 | "многострочная 178 | |строка 179 | |Я" 180 | ); 181 | 182 | КонецПроцедуры 183 | 184 | &Тест 185 | Процедура ТестДолжен_8() Экспорт 186 | 187 | Строка = 188 | "Я 189 | |строка 190 | |многострочная"; 191 | 192 | Результат = ПроцессорыКоллекций.ИзСтроки(Строка, Символы.ПС) 193 | .Фильтровать("Результат = СтрДлина(Элемент) > 1") 194 | .ВСтроку(Символы.ПС); 195 | 196 | Ожидаем.Что(Результат).Равно( 197 | "строка 198 | |многострочная" 199 | ); 200 | 201 | КонецПроцедуры 202 | 203 | &Тест 204 | Процедура ТестДолжен_8_1() Экспорт 205 | 206 | Строка = 207 | "Я 208 | |строка 209 | |многострочная"; 210 | 211 | Результат = ПроцессорыКоллекций.ИзСтроки(Строка, Символы.ПС) 212 | .Фильтровать("Элемент -> СтрДлина(Элемент) > 1") 213 | .ВСтроку(Символы.ПС); 214 | 215 | Ожидаем.Что(Результат).Равно( 216 | "строка 217 | |многострочная" 218 | ); 219 | 220 | КонецПроцедуры 221 | 222 | &Тест 223 | Процедура ТестДолжен_9() Экспорт 224 | 225 | Строка = 226 | "Я 227 | |строка 228 | |многострочная"; 229 | 230 | Результат = ПроцессорыКоллекций.ИзСтроки(Строка, Символы.ПС) 231 | .Сортировать("Результат = ВРЕГ(Элемент1) > ВРЕГ(Элемент2)") 232 | .ВСтроку(Символы.ПС); 233 | 234 | Ожидаем.Что(Результат).Равно( 235 | "многострочная 236 | |строка 237 | |Я" 238 | ); 239 | 240 | КонецПроцедуры 241 | 242 | &Тест 243 | Процедура ТестДолжен_9_1() Экспорт 244 | 245 | Строка = 246 | "Я 247 | |строка 248 | |многострочная"; 249 | 250 | Результат = ПроцессорыКоллекций.ИзСтроки(Строка, Символы.ПС) 251 | .Сортировать("Первый, Второй -> 252 | | Если ВРЕГ(Первый) > ВРЕГ(Второй) Тогда 253 | | Возврат 1; 254 | | ИначеЕсли ВРЕГ(Второй) > ВРЕГ(Первый) Тогда 255 | | Возврат -1; 256 | | Иначе 257 | | Возврат 0; 258 | | КонецЕсли;" 259 | ) 260 | .ВСтроку(Символы.ПС); 261 | 262 | Ожидаем.Что(Результат).Равно( 263 | "многострочная 264 | |строка 265 | |Я" 266 | ); 267 | 268 | КонецПроцедуры 269 | 270 | ФункцияФильтрации = Новый ОписаниеОповещения("ОбработчикФильтрации", ЭтотОбъект); 271 | ФункцияОбработки = Новый ОписаниеОповещения("ОбработчикОбработки", ЭтотОбъект); 272 | ФункцияСокращения = Новый ОписаниеОповещения("ОбработчикСокращения", ЭтотОбъект); 273 | 274 | ДействиеФильтрации = Новый Действие(ЭтотОбъект, "ДействиеФильтрации"); 275 | ДействиеСокращения = Новый Действие(ЭтотОбъект, "ДействиеСокращения"); 276 | ДействиеОбработки = Новый Действие(ЭтотОбъект, "ДействиеОбработки"); 277 | -------------------------------------------------------------------------------- /src/internal/Модули/ПроцессорыКоллекцийСлужебный.os: -------------------------------------------------------------------------------- 1 | #Использовать lambdas 2 | #Использовать notify 3 | 4 | Перем Лог; 5 | 6 | Процедура ФункцияСравнения(РезультатСортировки, ДополнительныеПараметры) Экспорт 7 | Элемент1 = ДополнительныеПараметры.Элемент1; 8 | Элемент2 = ДополнительныеПараметры.Элемент2; 9 | 10 | Если Элемент1 = Элемент2 Тогда 11 | РезультатСортировки = 0; 12 | ИначеЕсли Элемент1 > Элемент2 Тогда 13 | РезультатСортировки = 1; 14 | Иначе 15 | РезультатСортировки = -1; 16 | КонецЕсли; 17 | КонецПроцедуры 18 | 19 | Процедура ФункцияОбработки_Сообщить(Результат, ДополнительныеПараметры) Экспорт // BSLLS:UnusedParameters-off 20 | Элемент = ДополнительныеПараметры.Элемент; 21 | Сообщить(Элемент); 22 | КонецПроцедуры 23 | 24 | // Функция сравнивает два элемента и возвращает результат сравнения 25 | // 26 | // Параметры: 27 | // ЭлементПервый - Произвольный - Первый сравниваемый элемент 28 | // ЭлементВторой - Произвольный - Второй сравниваемый элемент 29 | // 30 | // Возвращаемое значение: 31 | // Число - Положительное, если первый элемент больше второго 32 | // Отрицательное если второй элемент больше первого 33 | // Ноль если элементы равны 34 | // 35 | Функция СравнениеЗначенийПрямойПорядок(ЭлементПервый, ЭлементВторой) Экспорт 36 | 37 | Если ЭлементПервый > ЭлементВторой Тогда 38 | Возврат 1; 39 | ИначеЕсли ЭлементПервый < ЭлементВторой Тогда 40 | Возврат -1; 41 | Иначе 42 | Возврат 0; 43 | КонецЕсли; 44 | 45 | КонецФункции 46 | 47 | // Функция сравнивает два элемента и возвращает результат сравнения 48 | // 49 | // Параметры: 50 | // ЭлементПервый - Произвольный - Первый сравниваемый элемент 51 | // ЭлементВторой - Произвольный - Второй сравниваемый элемент 52 | // 53 | // Возвращаемое значение: 54 | // Число - Положительное, если второй элемент больше первого 55 | // Отрицательное если первый элемент больше второго 56 | // Ноль если элементы равны 57 | // 58 | Функция СравнениеЗначенийОбратныйПорядок(ЭлементПервый, ЭлементВторой) Экспорт 59 | Возврат -СравнениеЗначенийПрямойПорядок(ЭлементПервый, ЭлементВторой); 60 | КонецФункции 61 | 62 | Функция РавенствоЗначений(ЭлементПервый, ЭлементВторой) Экспорт 63 | Возврат ЭлементПервый = ЭлементВторой; 64 | КонецФункции 65 | 66 | Функция ДействиеИзПараметров( 67 | ОписаниеФункции, 68 | Интерфейс, 69 | ДополнительныеПараметры, 70 | Отладка, 71 | ЭлементРезультат = Ложь) Экспорт 72 | 73 | Если ТипЗнч(ОписаниеФункции) = Тип("ОписаниеОповещения") 74 | Или ТипЗнч(ОписаниеФункции) = Тип("Строка") И СтрНайти(ОписаниеФункции, "->") = 0 Тогда 75 | 76 | Действие = ДействиеПоОписаниюОповещения( 77 | ОписаниеФункции, 78 | Интерфейс, 79 | ДополнительныеПараметры, 80 | Отладка, 81 | ЭлементРезультат 82 | ); 83 | 84 | ИначеЕсли ТипЗнч(ОписаниеФункции) = Тип("Строка") Тогда 85 | 86 | ЛямбдаВыражение = Лямбда.Выражение(ОписаниеФункции) 87 | .Интерфейс(Интерфейс) 88 | .Отладка(Отладка); 89 | 90 | Если ТипЗнч(ДополнительныеПараметры) = Тип("Структура") Тогда 91 | ЛямбдаВыражение.Контекст(ДополнительныеПараметры); 92 | ИначеЕсли Не ДополнительныеПараметры = Неопределено Тогда 93 | ЛямбдаВыражение.ЗахватитьОбъект(ДополнительныеПараметры); 94 | КонецЕсли; 95 | 96 | Действие = ЛямбдаВыражение.ВДействие(); 97 | 98 | Иначе 99 | 100 | Действие = ОписаниеФункции; 101 | 102 | КонецЕсли; 103 | 104 | Возврат Действие; 105 | 106 | КонецФункции 107 | 108 | Функция ДействиеПоОписаниюОповещения(ОписаниеОповещения, Интерфейс, ДополнительныеПараметры, Отладка, ЭлементРезультат) 109 | 110 | Лог.Предупреждение(" 111 | | Использование синтаксиса лямбда выражений без ""->"" а так же описания оповещения является устаревшим 112 | | и будет удален в последующих версиях, необходимо заменить места использования" 113 | ); 114 | 115 | Если Лог.Уровень() = УровниЛога.Отладка Тогда 116 | 117 | // Выведем стек вызова 118 | Попытка 119 | ВызватьИсключение "Стек вызовов:"; 120 | Исключение 121 | 122 | ИнформацияОбОшибке = ИнформацияОбОшибке(); 123 | СтекВызовов = ИнформацияОбОшибке.ПолучитьСтекВызовов(); 124 | МассивТекстИсключения = Новый Массив; 125 | 126 | Отступ = ""; 127 | СимволОтступа = " "; 128 | 129 | Для Каждого КадрСтекаВызовов Из СтекВызовов Цикл 130 | 131 | Отступ = Отступ + СимволОтступа; 132 | 133 | СтрокаСтекаВызовов = СтрШаблон( 134 | "%1%2 / Метод %3 / Строка %4", 135 | Отступ, 136 | КадрСтекаВызовов.ИмяМодуля, 137 | КадрСтекаВызовов.Метод, 138 | Формат(КадрСтекаВызовов.НомерСтроки, "ЧГ=") 139 | ); 140 | МассивТекстИсключения.Добавить(СтрокаСтекаВызовов); 141 | 142 | КонецЦикла; 143 | 144 | Лог.Отладка(СтрСоединить(МассивТекстИсключения, Символы.ПС)); 145 | 146 | КонецПопытки; 147 | 148 | КонецЕсли; 149 | 150 | ЭтоФункция = Интерфейс.ПолучитьКартуИнтерфейса()[0].ЭтоФункция; 151 | КоличествоПараметров = Интерфейс.ПолучитьКартуИнтерфейса()[0].КоличествоПараметров; 152 | 153 | Если ДополнительныеПараметры = Неопределено Тогда 154 | ДополнительныеПараметры = Новый Структура(); 155 | КонецЕсли; 156 | 157 | Если КоличествоПараметров = 1 Тогда 158 | Префикс = "(Элемент) -> ДополнительныеПараметры.Вставить(""Элемент"", Элемент);"; 159 | Иначе 160 | Префикс = "(Элемент1, Элемент2) -> 161 | | ДополнительныеПараметры.Вставить(""Элемент1"", Элемент1); 162 | | ДополнительныеПараметры.Вставить(""Элемент2"", Элемент2);"; 163 | КонецЕсли; 164 | 165 | Если ЭлементРезультат Тогда 166 | 167 | Префикс = Префикс + Символы.ПС + " 168 | | Результат = Элемент1; 169 | | Элемент = Элемент2; 170 | | ДополнительныеПараметры.Вставить(""Элемент"", Элемент);"; 171 | 172 | Иначе 173 | Префикс = Префикс + Символы.ПС + "Результат = Неопределено;"; 174 | КонецЕсли; 175 | 176 | Если ЭтоФункция Тогда 177 | Суффикс = "; Возврат Результат;"; 178 | Иначе 179 | Суффикс = ""; 180 | КонецЕсли; 181 | 182 | Если ТипЗнч(ОписаниеОповещения) = Тип("Строка") Тогда 183 | 184 | Возврат Лямбда.Выражение(Префикс + ОписаниеОповещения + Суффикс) 185 | .Отладка(Отладка) 186 | .Интерфейс(Интерфейс) 187 | .Контекст(Новый Структура("ДополнительныеПараметры", ДополнительныеПараметры)) 188 | .ВДействие(); 189 | 190 | Иначе 191 | 192 | ДополнитьСтруктуру(ДополнительныеПараметры, ОписаниеОповещения.ДополнительныеПараметры, Истина); 193 | 194 | Возврат Лямбда 195 | .Выражение(Префикс + " 196 | | Оповещение.ДополнительныеПараметры = ДополнительныеПараметры; 197 | | ОписанияОповещений.ВыполнитьОбработкуОповещения(Оповещение, Результат)" + Суффикс) 198 | .Отладка(Отладка) 199 | .Интерфейс(Интерфейс) 200 | .Контекст(Новый Структура( 201 | "Оповещение, ДополнительныеПараметры", 202 | ОписаниеОповещения, 203 | ДополнительныеПараметры 204 | )) 205 | .ВДействие(); 206 | 207 | КонецЕсли; 208 | 209 | КонецФункции 210 | 211 | // Дополняет структуру значениями из другой структуры. 212 | // 213 | // Параметры: 214 | // Приемник - Структура - коллекция, в которую будут добавляться новые значения. 215 | // Источник - Структура - коллекция, из которой будут считываться пары Ключ и Значение для заполнения. 216 | // Заменять - Булево, Неопределено - что делать в местах пересечения ключей источника и приемника: 217 | // - Истина - заменять значения приемника (самый быстрый способ), 218 | // - Ложь - не заменять значения приемника (пропускать), 219 | // - Неопределено - значение по умолчанию. Бросать исключение. 220 | // 221 | // Функция скопирована из "Библиотеки Стандартных Подсистем" на следующих условиях: 222 | // 223 | // Copyright (c) 2018, ООО 1С-Софт 224 | // Все права защищены. Эта программа и сопроводительные материалы предоставляются 225 | // в соответствии с условиями лицензии Attribution 4.0 International (CC BY 4.0) 226 | // Текст лицензии доступен по ссылке: 227 | // https://creativecommons.org/licenses/by/4.0/legalcode 228 | // 229 | // В функцию внесены следующие изменения: 230 | // - использование СтроковыеФункцииКлиентСервер.ПодставитьПараметрыВСтроку заменено на СтрШаблон; 231 | // - добавлена инициализиация структур приемника и источника 232 | // 233 | Процедура ДополнитьСтруктуру(Приемник, Источник, Заменять = Неопределено) 234 | 235 | Если Приемник = Неопределено Тогда 236 | Приемник = Новый Структура; 237 | КонецЕсли; 238 | 239 | Если Источник = Неопределено Тогда 240 | Источник = Новый Структура; 241 | КонецЕсли; 242 | 243 | Для Каждого Элемент Из Источник Цикл 244 | Если Заменять <> Истина И Приемник.Свойство(Элемент.Ключ) Тогда 245 | Если Заменять = Ложь Тогда 246 | Продолжить; 247 | Иначе 248 | ВызватьИсключение СтрШаблон(НСтр("ru = 'Пересечение ключей источника и приемника: ""%1"".'"), Элемент.Ключ); 249 | КонецЕсли; 250 | КонецЕсли; 251 | Приемник.Вставить(Элемент.Ключ, Элемент.Значение); 252 | КонецЦикла; 253 | 254 | КонецПроцедуры 255 | 256 | Лог = Логирование.ПолучитьЛог("oscript.lib.stream"); 257 | -------------------------------------------------------------------------------- /src/Модули/ПроцессорыКоллекций.os: -------------------------------------------------------------------------------- 1 | #Использовать notify 2 | 3 | #Использовать "../internal" 4 | 5 | Перем СравнениеЗначенийПрямойПорядок; // Делегат на функцию сравнения в прямом порядке 6 | Перем СравнениеЗначенийОбратныйПорядок; // Делегат на функцию сравнения в обратном порядке 7 | Перем РавенствоЗначений; // Делегат на функцию равенства 8 | 9 | Перем Лог; // Инстанс логера 10 | 11 | // Создать ПроцессорКоллекций на основании переданной коллекции. 12 | // 13 | // Параметры: 14 | // Коллекция - Произвольный - Коллекция (Массив, ТаблицаЗначений...), на основании которой нужно 15 | // сформировать ПроцессорКоллекций. 16 | // 17 | // Возвращаемое значение: 18 | // ПроцессорКоллекций - Инстанс класса ПроцессорКоллекций, заполненный переданной коллекцией. 19 | // 20 | Функция ИзКоллекции(Коллекция) Экспорт 21 | ПроцессорКоллекций = Новый ПроцессорКоллекций(); 22 | ПроцессорКоллекций.УстановитьКоллекцию(Коллекция); 23 | 24 | Возврат ПроцессорКоллекций; 25 | КонецФункции 26 | 27 | // Создать ПроцессорКоллекций на основании переданной строки. 28 | // Переданная строка преобразуется в коллекцию путем разделения строк. 29 | // 30 | // Параметры: 31 | // Строка - Строка - Строка, на основании которой нужно сформировать ПроцессорКоллекций. 32 | // РазделительСтрок - Строка - Разделитель строк, применяемый к Строке для получения коллекции. 33 | // Если не передан, строка разделяется на элементы посимвольно. 34 | // ВключатьПустые - Булево - Указывает необходимость включать в коллекцию пустые строки, 35 | // которые могут образоваться в результате разделения исходной строки. 36 | // 37 | // Возвращаемое значение: 38 | // ПроцессорКоллекций - Инстанс класса ПроцессорКоллекций. 39 | // 40 | Функция ИзСтроки(Строка, РазделительСтрок = Неопределено, ВключатьПустые = Истина) Экспорт 41 | 42 | Если РазделительСтрок = Неопределено Тогда 43 | Коллекция = Новый Массив; 44 | ДлинаСтроки = СтрДлина(Строка); 45 | Для сч = 1 По ДлинаСтроки Цикл 46 | Коллекция.Добавить(Сред(Строка, сч, 1)); 47 | КонецЦикла; 48 | Иначе 49 | Коллекция = СтрРазделить(Строка, РазделительСтрок, ВключатьПустые); 50 | КонецЕсли; 51 | 52 | ПроцессорКоллекций = Новый ПроцессорКоллекций(); 53 | ПроцессорКоллекций.УстановитьКоллекцию(Коллекция); 54 | 55 | Возврат ПроцессорКоллекций; 56 | 57 | КонецФункции 58 | 59 | // Создать ПроцессорКоллекций на основании переданного набора значений. 60 | // Добавляет элемент в ПроцессорКоллекций, если он не равен NULL. 61 | // 62 | // Параметры: 63 | // Элемент1 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 64 | // Элемент2 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 65 | // Элемент3 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 66 | // Элемент4 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 67 | // Элемент5 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 68 | // Элемент6 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 69 | // Элемент7 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 70 | // Элемент8 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 71 | // Элемент9 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 72 | // Элемент10 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 73 | // Элемент11 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 74 | // Элемент12 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 75 | // Элемент13 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 76 | // Элемент14 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 77 | // Элемент15 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 78 | // Элемент16 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 79 | // Элемент17 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 80 | // Элемент18 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 81 | // Элемент19 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 82 | // Элемент20 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 83 | // Элемент21 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 84 | // Элемент22 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 85 | // Элемент23 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 86 | // Элемент24 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 87 | // Элемент25 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 88 | // Элемент26 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 89 | // Элемент27 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 90 | // Элемент28 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 91 | // Элемент29 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 92 | // Элемент30 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 93 | // Элемент31 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 94 | // Элемент32 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 95 | // 96 | // Возвращаемое значение: 97 | // ПроцессорКоллекций - Инстанс класса ПроцессорКоллекций, заполненный переданным набором. 98 | // 99 | Функция ИзНабора( 100 | // BSLLS:NumberOfParams-off 101 | // BSLLS:NumberOfOptionalParams-off 102 | // BSLLS:UnusedParameters-off 103 | Элемент1 = NULL, Элемент2 = NULL, Элемент3 = NULL, Элемент4 = NULL, Элемент5 = NULL, 104 | Элемент6 = NULL, Элемент7 = NULL, Элемент8 = NULL, Элемент9 = NULL, Элемент10 = NULL, 105 | Элемент11 = NULL, Элемент12 = NULL, Элемент13 = NULL, Элемент14 = NULL, Элемент15 = NULL, 106 | Элемент16 = NULL, Элемент17 = NULL, Элемент18 = NULL, Элемент19 = NULL, Элемент20 = NULL, 107 | Элемент21 = NULL, Элемент22 = NULL, Элемент23 = NULL, Элемент24 = NULL, Элемент25 = NULL, 108 | Элемент26 = NULL, Элемент27 = NULL, Элемент28 = NULL, Элемент29 = NULL, Элемент30 = NULL, 109 | Элемент31 = NULL, Элемент32 = NULL 110 | // BSLLS:NumberOfParams-on 111 | // BSLLS:NumberOfOptionalParams-on 112 | // BSLLS:UnusedParameters-on 113 | ) Экспорт 114 | 115 | Коллекция = Новый Массив; 116 | Для сч = 1 По 32 Цикл 117 | ДобавитьНеПустоеЗначениеВКоллекцию(Коллекция, Вычислить("Элемент" + сч)); 118 | КонецЦикла; 119 | 120 | ПроцессорКоллекций = Новый ПроцессорКоллекций(); 121 | ПроцессорКоллекций.УстановитьКоллекцию(Коллекция); 122 | 123 | Возврат ПроцессорКоллекций; 124 | 125 | КонецФункции 126 | 127 | // Устарела. Следует использовать см. ПроцессорыКоллекций.СтандартнаяФункцияСравненияПрямойПорядок 128 | // Стандартная функция сравнения. 129 | // Сравнивает значения элементов коллекции через операторы ">", "<" и "=". 130 | // 131 | // Возвращаемое значение: 132 | // ОписаниеОповещения - Инстанс класса ОписаниеОповещения, указывающий на стандартную функцию сравнения. 133 | // 134 | Функция СтандартнаяФункцияСравнения() Экспорт 135 | 136 | Лог.Предупреждение(" 137 | |Метод ПроцессорыКоллекций.СтандартнаяФункцияСравнения объявлен устаревшим и будет удалён в последующих релизах 138 | |Следует использовать новые методы: СтандартнаяФункцияСравненияПрямойПорядок, СтандартнаяФункцияСравненияОбратныйПорядок" 139 | ); 140 | 141 | ДополнительныеПараметры = Новый Структура; 142 | ДополнительныеПараметры.Вставить("Элемент1"); 143 | ДополнительныеПараметры.Вставить("Элемент2"); 144 | 145 | ФункцияСравнения = Новый ОписаниеОповещения("ФункцияСравнения", ПроцессорыКоллекцийСлужебный, ДополнительныеПараметры); 146 | Возврат ФункцияСравнения; 147 | КонецФункции 148 | 149 | // Стандартная функция сравнения. 150 | // Сравнивает значения элементов коллекции через операторы ">", "<" и "=". 151 | // 152 | // Возвращаемое значение: 153 | // Действие - Делегат на стандартный метод сравнения 154 | // 155 | Функция СтандартнаяФункцияСравненияПрямойПорядок() Экспорт 156 | 157 | Если СравнениеЗначенийПрямойПорядок = Неопределено Тогда 158 | СравнениеЗначенийПрямойПорядок = Новый Действие(ПроцессорыКоллекцийСлужебный, "СравнениеЗначенийПрямойПорядок"); 159 | КонецЕсли; 160 | 161 | Возврат СравнениеЗначенийПрямойПорядок; 162 | 163 | КонецФункции 164 | 165 | // Стандартная функция сравнения в обратном порядке 166 | // Сравнивает значения элементов коллекции через операторы ">", "<" и "=". 167 | // 168 | // Возвращаемое значение: 169 | // Действие - Делегат на стандартный метод сравнения в обратном порядке 170 | // 171 | Функция СтандартнаяФункцияСравненияОбратныйПорядок() Экспорт 172 | 173 | Если СравнениеЗначенийОбратныйПорядок = Неопределено Тогда 174 | СравнениеЗначенийОбратныйПорядок = Новый Действие(ПроцессорыКоллекцийСлужебный, "СравнениеЗначенийОбратныйПорядок"); 175 | КонецЕсли; 176 | 177 | Возврат СравнениеЗначенийОбратныйПорядок; 178 | 179 | КонецФункции 180 | 181 | // Стандартная функция проверки на равенство 182 | // Сравнивает значения элементов коллекции через "=". 183 | // 184 | // Возвращаемое значение: 185 | // Действие - Делегат на стандартный метод проверки на равенство 186 | // 187 | Функция СтандартнаяФункцияРавенства() Экспорт 188 | 189 | Если РавенствоЗначений = Неопределено Тогда 190 | РавенствоЗначений = Новый Действие(ПроцессорыКоллекцийСлужебный, "РавенствоЗначений"); 191 | КонецЕсли; 192 | 193 | Возврат РавенствоЗначений; 194 | 195 | КонецФункции 196 | 197 | // Устарела. Используйте выражение "Элемент -> Сообщить(Элемент)" 198 | // Стандартная функция обработки - "Сообщить". 199 | // Выполняет процедуру "Сообщить()" над каждым элементом коллекции. 200 | // 201 | // Возвращаемое значение: 202 | // ОписаниеОповещения - Инстанс класса ОписаниеОповещения, указывающий на стандартную функцию обработки. 203 | // 204 | Функция СтандартнаяФункцияОбработки_Сообщить() Экспорт 205 | 206 | Лог.Предупреждение(" 207 | |Метод ПроцессорыКоллекций.СтандартнаяФункцияОбработки_Сообщить объявлен устаревшим и будет удалён в последующих релизах 208 | |Используйте выражение: ""Элемент -> Сообщить(Элемент)""" 209 | ); 210 | 211 | ФункцияОбработки = Новый ОписаниеОповещения("ФункцияОбработки_Сообщить", ПроцессорыКоллекцийСлужебный); 212 | Возврат ФункцияОбработки; 213 | 214 | КонецФункции 215 | 216 | Процедура ДобавитьНеПустоеЗначениеВКоллекцию(Коллекция, Значение) 217 | Если Значение <> NULL Тогда 218 | Коллекция.Добавить(Значение); 219 | КонецЕсли; 220 | КонецПроцедуры 221 | 222 | Лог = Логирование.ПолучитьЛог("oscript.lib.stream"); 223 | -------------------------------------------------------------------------------- /tests/ТерминальныеМетоды.os: -------------------------------------------------------------------------------- 1 | #Использовать asserts 2 | #Использовать notify 3 | #Использовать ".." 4 | 5 | Перем ВнешнийМассив; 6 | 7 | Функция ПолучитьНачальныйМассив() 8 | Массив = Новый Массив; 9 | Массив.Добавить(1); 10 | Массив.Добавить(0); 11 | Массив.Добавить(3); 12 | Массив.Добавить(2); 13 | Массив.Добавить(3); 14 | Массив.Добавить(1); 15 | 16 | Возврат Массив; 17 | КонецФункции 18 | 19 | Функция ПолучитьПроцессорКоллекций() 20 | 21 | Возврат ПроцессорыКоллекций.ИзКоллекции(ПолучитьНачальныйМассив()); 22 | 23 | КонецФункции 24 | 25 | Процедура ФункцияОбработкиСПроверкойДопПараметров(Результат, ДополнительныеПараметры) Экспорт 26 | Результат = ДополнительныеПараметры.ПроверяемыйПараметр; 27 | КонецПроцедуры 28 | 29 | &Тест 30 | Процедура ТестДолжен_ПолучитьПервый() Экспорт 31 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 32 | Результат = ПроцессорКоллекций.ПолучитьПервый(); 33 | Ожидаем.Что(Результат).ИмеетТип("Число").Равно(1); 34 | КонецПроцедуры 35 | 36 | &Тест 37 | Процедура ТестДолжен_ВернутьМассив() Экспорт 38 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 39 | Результат = ПроцессорКоллекций.ВМассив(); 40 | Ожидаем.Что(Результат).ИмеетТип("Массив").ИмеетДлину(6); 41 | КонецПроцедуры 42 | 43 | &Тест 44 | Процедура ТестДолжен_ВернутьСтроку() Экспорт 45 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 46 | Результат = ПроцессорКоллекций.ВСтроку(); 47 | Ожидаем.Что(Результат).ИмеетТип("Строка").ИмеетДлину(6); 48 | КонецПроцедуры 49 | 50 | &Тест 51 | Процедура ТестДолжен_ПолучитьКоличество() Экспорт 52 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 53 | Результат = ПроцессорКоллекций.Количество(); 54 | Ожидаем.Что(Результат).Равно(6); 55 | КонецПроцедуры 56 | 57 | &Тест 58 | Процедура ТестДолжен_ВыполнитьДляКаждого() Экспорт 59 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 60 | НачальныйМассив = ПолучитьНачальныйМассив(); 61 | 62 | ДополнительныеПараметры = Новый Структура; 63 | ДополнительныеПараметры.Вставить("ВнешнийМассив", Новый Массив); 64 | ПроцессорКоллекций.ДляКаждого("ДополнительныеПараметры.ВнешнийМассив.Добавить(Элемент + 1)", ДополнительныеПараметры); 65 | Ожидаем.Что(ДополнительныеПараметры.ВнешнийМассив).ИмеетДлину(НачальныйМассив.Количество()); 66 | Для сч = 0 По ДополнительныеПараметры.ВнешнийМассив.ВГраница() Цикл 67 | Ожидаем.Что(ДополнительныеПараметры.ВнешнийМассив[сч]).Равно(НачальныйМассив[сч] + 1); 68 | КонецЦикла; 69 | КонецПроцедуры 70 | 71 | &Тест 72 | Процедура ТестДолжен_ВыполнитьДляКаждого_Лямбда() Экспорт 73 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 74 | НачальныйМассив = ПолучитьНачальныйМассив(); 75 | 76 | ДополнительныеПараметры = Новый Структура; 77 | ДополнительныеПараметры.Вставить("ВнешнийМассив", Новый Массив); 78 | ПроцессорКоллекций.ДляКаждого("Элемент -> ВнешнийМассив.Добавить(Элемент + 1)", ДополнительныеПараметры); 79 | Ожидаем.Что(ДополнительныеПараметры.ВнешнийМассив).ИмеетДлину(НачальныйМассив.Количество()); 80 | Для сч = 0 По ДополнительныеПараметры.ВнешнийМассив.ВГраница() Цикл 81 | Ожидаем.Что(ДополнительныеПараметры.ВнешнийМассив[сч]).Равно(НачальныйМассив[сч] + 1); 82 | КонецЦикла; 83 | КонецПроцедуры 84 | 85 | &Тест 86 | Процедура ТестДолжен_ВыполнитьДляКаждого_Захват() Экспорт 87 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 88 | НачальныйМассив = ПолучитьНачальныйМассив(); 89 | 90 | ВнешнийМассив = Новый Массив; 91 | 92 | ПроцессорКоллекций.ДляКаждого("Элемент -> ВнешнийМассив.Добавить(Элемент + 1)", ЭтотОбъект); 93 | Ожидаем.Что(ВнешнийМассив).ИмеетДлину(НачальныйМассив.Количество()); 94 | Для сч = 0 По ВнешнийМассив.ВГраница() Цикл 95 | Ожидаем.Что(ВнешнийМассив[сч]).Равно(НачальныйМассив[сч] + 1); 96 | КонецЦикла; 97 | КонецПроцедуры 98 | 99 | &Тест 100 | Процедура ТестДолжен_ПолучитьМинимальныйЭлемент() Экспорт 101 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 102 | Результат = ПроцессорКоллекций.Минимум(); 103 | Ожидаем.Что(Результат).Равно(0); 104 | КонецПроцедуры 105 | 106 | &Тест 107 | Процедура ТестДолжен_ПолучитьМаксимальныйЭлемент() Экспорт 108 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 109 | Результат = ПроцессорКоллекций.Максимум(); 110 | Ожидаем.Что(Результат).Равно(3); 111 | КонецПроцедуры 112 | 113 | &Тест 114 | Процедура ТестДолжен_ВыполнитьСокращение() Экспорт 115 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 116 | 117 | Результат = ПроцессорКоллекций.Сократить("Результат = Результат + Элемент", 0); 118 | Ожидаем.Что(Результат).Равно(10); 119 | КонецПроцедуры 120 | 121 | &Тест 122 | Процедура ТестДолжен_ВыполнитьСокращение_Лямбда() Экспорт 123 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 124 | 125 | Результат = ПроцессорКоллекций.Сократить("Результат, Элемент -> Результат + Элемент", 0); 126 | Ожидаем.Что(Результат).Равно(10); 127 | КонецПроцедуры 128 | 129 | &Тест 130 | Процедура ТестДолжен_ПолучитьМассив() Экспорт 131 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 132 | НачальныйМассив = ПолучитьНачальныйМассив(); 133 | 134 | Результат = ПроцессорКоллекций.Получить(Тип("Массив")); 135 | Ожидаем.Что(Результат).ИмеетТип("Массив").ИмеетДлину(НачальныйМассив.Количество()); 136 | 137 | Для сч = 0 По НачальныйМассив.ВГраница() Цикл 138 | Ожидаем.Что(НачальныйМассив[сч]).Равно(Результат[сч]); 139 | КонецЦикла; 140 | 141 | КонецПроцедуры 142 | 143 | &Тест 144 | Процедура ТестДолжен_ПолучитьТаблицуЗначений() Экспорт 145 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 146 | НачальныйМассив = ПолучитьНачальныйМассив(); 147 | 148 | Результат = ПроцессорКоллекций.Получить(Тип("ТаблицаЗначений")); 149 | Ожидаем.Что(Результат).ИмеетТип("ТаблицаЗначений").ИмеетДлину(НачальныйМассив.Количество()); 150 | 151 | Для сч = 0 По НачальныйМассив.ВГраница() Цикл 152 | Ожидаем.Что(НачальныйМассив[сч]).Равно(Результат[сч].Значение); 153 | КонецЦикла; 154 | 155 | КонецПроцедуры 156 | 157 | &Тест 158 | Процедура ТестДолжен_ПолучитьСписокЗначений() Экспорт 159 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 160 | НачальныйМассив = ПолучитьНачальныйМассив(); 161 | 162 | Результат = ПроцессорКоллекций.Получить(Тип("СписокЗначений")); 163 | Ожидаем.Что(Результат).ИмеетТип("СписокЗначений").ИмеетДлину(НачальныйМассив.Количество()); 164 | 165 | Для сч = 0 По НачальныйМассив.ВГраница() Цикл 166 | Ожидаем.Что(НачальныйМассив[сч]).Равно(Результат[сч].Значение); 167 | КонецЦикла; 168 | 169 | КонецПроцедуры 170 | 171 | Процедура ТестДолжен_ПолучитьСтруктуру() 172 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 173 | НачальныйМассив = ПолучитьНачальныйМассив(); 174 | 175 | Результат = ПроцессорКоллекций.Получить(Тип("Структура")); 176 | Ожидаем.Что(Результат).ИмеетТип("Структура").ИмеетДлину(НачальныйМассив.Количество()); 177 | 178 | Для сч = 0 По НачальныйМассив.ВГраница() Цикл 179 | Ожидаем.Что(НачальныйМассив[сч]).Равно(Результат[сч].Значение); 180 | КонецЦикла; 181 | 182 | КонецПроцедуры 183 | 184 | Процедура ТестДолжен_ПолучитьСоответствие() 185 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 186 | НачальныйМассив = ПолучитьНачальныйМассив(); 187 | 188 | Результат = ПроцессорКоллекций.Получить(Тип("Соответствие")); 189 | Ожидаем.Что(Результат).ИмеетТип("Соответствие").ИмеетДлину(НачальныйМассив.Количество()); 190 | 191 | Для сч = 0 По НачальныйМассив.ВГраница() Цикл 192 | Ожидаем.Что(НачальныйМассив[сч]).Равно(Результат[сч].Значение); 193 | КонецЦикла; 194 | 195 | КонецПроцедуры 196 | 197 | &Тест 198 | Процедура ТестДолжен_ПроверитьЛюбойСоответствует() Экспорт 199 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 200 | 201 | Результат = ПроцессорКоллекций.ЛюбойСоответствует("Результат = Элемент > 1"); 202 | Ожидаем.Что(Результат).ЭтоИстина(); 203 | 204 | Результат = ПроцессорКоллекций.ЛюбойСоответствует("Результат = Элемент < 0"); 205 | Ожидаем.Что(Результат).ЭтоЛожь(); 206 | КонецПроцедуры 207 | 208 | &Тест 209 | Процедура ТестДолжен_ПроверитьЛюбойСоответствует_Лямбда() Экспорт 210 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 211 | 212 | Результат = ПроцессорКоллекций.ЛюбойСоответствует("Элемент -> Элемент > 1"); 213 | Ожидаем.Что(Результат).ЭтоИстина(); 214 | 215 | Результат = ПроцессорКоллекций.ЛюбойСоответствует("Элемент -> Элемент < 0"); 216 | Ожидаем.Что(Результат).ЭтоЛожь(); 217 | КонецПроцедуры 218 | 219 | &Тест 220 | Процедура ТестДолжен_ПроверитьВсеСоответствуют() Экспорт 221 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 222 | 223 | Результат = ПроцессорКоллекций.ВсеСоответствуют("Результат = Элемент >= 0"); 224 | Ожидаем.Что(Результат).ЭтоИстина(); 225 | 226 | Результат = ПроцессорКоллекций.ВсеСоответствуют("Результат = Элемент < 2"); 227 | Ожидаем.Что(Результат).ЭтоЛожь(); 228 | КонецПроцедуры 229 | 230 | &Тест 231 | Процедура ТестДолжен_ПроверитьВсеСоответствуют_Лямбда() Экспорт 232 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 233 | 234 | Результат = ПроцессорКоллекций.ВсеСоответствуют("Элемент -> Элемент >= 0"); 235 | Ожидаем.Что(Результат).ЭтоИстина(); 236 | 237 | Результат = ПроцессорКоллекций.ВсеСоответствуют("Элемент -> Элемент < 2"); 238 | Ожидаем.Что(Результат).ЭтоЛожь(); 239 | КонецПроцедуры 240 | 241 | &Тест 242 | Процедура ТестДолжен_ПроверитьВсеНеСоответствуют() Экспорт 243 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 244 | 245 | Результат = ПроцессорКоллекций.ВсеНеСоответствуют("Результат = Элемент < 0"); 246 | Ожидаем.Что(Результат).ЭтоИстина(); 247 | 248 | Результат = ПроцессорКоллекций.ВсеНеСоответствуют("Результат = Элемент > 2"); 249 | Ожидаем.Что(Результат).ЭтоЛожь(); 250 | КонецПроцедуры 251 | 252 | &Тест 253 | Процедура ТестДолжен_ПроверитьВсеНеСоответствуют_Лямбда() Экспорт 254 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 255 | 256 | Результат = ПроцессорКоллекций.ВсеНеСоответствуют("Элемент -> Элемент < 0"); 257 | Ожидаем.Что(Результат).ЭтоИстина(); 258 | 259 | Результат = ПроцессорКоллекций.ВсеНеСоответствуют("Элемент -> Элемент > 2"); 260 | Ожидаем.Что(Результат).ЭтоЛожь(); 261 | КонецПроцедуры 262 | 263 | &Тест 264 | Процедура ТестДолжен_ПроверитьПробросДополнительныхПараметровВОповещениеДляКаждого() Экспорт 265 | ПроцессорКоллекций = ПолучитьПроцессорКоллекций(); 266 | 267 | ДополнительныеПараметры = Новый Структура("ПроверяемыйПараметр"); 268 | ФункцияОбработки = Новый ОписаниеОповещения( 269 | "ФункцияОбработкиСПроверкойДопПараметров", 270 | ЭтотОбъект, 271 | ДополнительныеПараметры 272 | ); 273 | 274 | // Ожидаем, что все варианты не выкинут исключения 275 | ПроцессорКоллекций.ДляКаждого(ФункцияОбработки); 276 | ПроцессорКоллекций.ДляКаждого("Результат = ДополнительныеПараметры.ПроверяемыйПараметр;", ДополнительныеПараметры); 277 | 278 | ФункцияОбработки = Новый ОписаниеОповещения( 279 | "ФункцияОбработкиСПроверкойДопПараметров", 280 | ЭтотОбъект 281 | ); 282 | ПроцессорКоллекций.ДляКаждого(ФункцияОбработки, ДополнительныеПараметры); 283 | 284 | КонецПроцедуры 285 | -------------------------------------------------------------------------------- /src/Классы/ПроцессорКоллекций.os: -------------------------------------------------------------------------------- 1 | #Использовать logos 2 | #Использовать strings 3 | #Использовать tempfiles 4 | 5 | #Использовать "../internal" 6 | 7 | Перем Лог; 8 | 9 | Перем Коллекция; 10 | Перем КэшКолонок; 11 | 12 | Перем Конвейер; 13 | Перем НомерПроходаКонвейера; 14 | 15 | // Флаг поддержки возможности отладки добавленных методов 16 | Перем Отладка; 17 | 18 | // Общее API 19 | 20 | // Устанавливает коллекцию для обработки Процессора коллекций. 21 | // 22 | // Параметры: 23 | // НоваяКоллекция - Массив, ТаблицаЗначений, ДеревоЗначений - Коллекция, устанавливаемая в процессор. 24 | // 25 | Процедура УстановитьКоллекцию(НоваяКоллекция) Экспорт 26 | 27 | Коллекция = Новый Массив; 28 | 29 | Для Каждого ЭлементНовойКоллекции Из НоваяКоллекция Цикл 30 | Коллекция.Добавить(ЭлементНовойКоллекции); 31 | КонецЦикла; 32 | 33 | КэшКолонок = Новый Массив; 34 | 35 | ЕстьРеквизитКолонки = Истина; 36 | Попытка 37 | Колонки = НоваяКоллекция.Колонки; 38 | Исключение 39 | ЕстьРеквизитКолонки = Ложь; 40 | КонецПопытки; 41 | 42 | Если ЕстьРеквизитКолонки Тогда 43 | Для Каждого Колонка Из НоваяКоллекция.Колонки Цикл 44 | КэшКолонок.Добавить(Колонка); 45 | КонецЦикла; 46 | КонецЕсли; 47 | 48 | Лог.Отладка("Кэш колонок содержит %1 колонок", КэшКолонок.Количество()); 49 | Лог.Отладка("Установлена коллекция размером %1", Коллекция.Количество()); 50 | 51 | КонецПроцедуры 52 | 53 | // Включает возможность отладки. Достигается сохранением текста модуля во временный файл. 54 | // 55 | // Возвращаемое значение: 56 | // ПроцессорКоллекций - Ссылка на текущий инстанс ПроцессорКоллекций 57 | // 58 | Функция Отладка(Включена = Истина) Экспорт 59 | Отладка = Включена; 60 | Возврат ЭтотОбъект; 61 | КонецФункции 62 | 63 | // Конвейерные методы 64 | 65 | // Получить первые N элементов. 66 | // Конвейерный метод. 67 | // 68 | // Параметры: 69 | // Количество - Число - Число отбираемых элементов. 70 | // 71 | // Возвращаемое значение: 72 | // ПроцессорКоллекций - Инстанс класса "ПроцессорКоллекций". 73 | // 74 | Функция Первые(Количество) Экспорт 75 | ДобавитьШагВКонвейер(Новый ШагКонвейераПервые(Количество)); 76 | Возврат ЭтотОбъект; 77 | КонецФункции 78 | 79 | // Пропустить первые N элементов. 80 | // Конвейерный метод. 81 | // 82 | // Параметры: 83 | // Количество - Число - Число пропускаемых элементов. 84 | // 85 | // Возвращаемое значение: 86 | // ПроцессорКоллекций - Инстанс класса "ПроцессорКоллекций". 87 | // 88 | Функция Пропустить(Количество) Экспорт 89 | ДобавитьШагВКонвейер(Новый ШагКонвейераПропустить(Количество)); 90 | Возврат ЭтотОбъект; 91 | КонецФункции 92 | 93 | // Выбрать различные элементы. 94 | // Конвейерный метод. 95 | // 96 | // Параметры: 97 | // ФункцияРавенства - Строка - Лямбда выражение функция с двумя параметрами в которые будут переданы два элемента, 98 | // и которая возвращает Булево, Истина если элементы равны, Ложь в противном случае 99 | // - Действие - Делегат на функцию с двумя параметрами, в которые будут переданы два элемента, 100 | // и которая возвращает Булево, Истина если элементы равны, Ложь в противном случае 101 | // - Неопределено - см. ПроцессорыКоллекций.СтандартнаяФункцияРавенства(), 102 | // проверка "Элемент1 = Элемент2" 103 | // 104 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 105 | // значения будут доступны по обращению к ключу как к переменной. 106 | // При передачи действия в первом параметре, этот параметр игнорируется 107 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 108 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 109 | // При передачи действия в первом параметре, этот параметр игнорируется 110 | // 111 | // Возвращаемое значение: 112 | // ПроцессорКоллекций - Инстанс класса "ПроцессорКоллекций". 113 | // 114 | // Примеры: 115 | // 116 | // ПроцессорКоллекций = ПроцессорыКоллекций.ИзНабора( 117 | // Новый Структура("Имя, Возраст", "Вася", 25), 118 | // Новый Структура("Имя, Возраст", "Петя", 27), 119 | // Новый Структура("Имя, Возраст", "Ваня", 25) 120 | // ); 121 | // 122 | // // 1: 123 | // ПроцессорКоллекций.Различные("(ЧеловекПервый, ЧеловекВторой) -> ЧеловекПервый.Возраст = ЧеловекВторой.Возраст"); 124 | // 125 | // // В коллекции останутся: Вася(25) и Петя(27) 126 | // 127 | // // 2: 128 | // Функция МояФункцияФункцияРавенства(ЭлементПервый, ЭлементВторой) Экспорт 129 | // Возврат ЧеловекПервый.Возраст = ЧеловекВторой.Возраст; 130 | // КонецФункции 131 | // 132 | // ПроцессорКоллекций.Различные(Новый Действие(ЭтотОбъект, "МояФункцияФункцияРавенства")); 133 | // 134 | // // В коллекции останутся: Вася(25) и Петя(27) 135 | // 136 | Функция Различные(Знач ФункцияРавенства = Неопределено, Знач ДополнительныеПараметры = Неопределено) Экспорт 137 | ДобавитьШагВКонвейер(Новый ШагКонвейераРазличные(ФункцияРавенства, ДополнительныеПараметры, Отладка)); 138 | Возврат ЭтотОбъект; 139 | КонецФункции 140 | 141 | // Обработать каждый элемент коллекции. 142 | // Конвейерный метод. 143 | // 144 | // Параметры: 145 | // ФункцияОбработки - Строка - Лямбда выражение функция с одним параметром в который будет передан элемент, 146 | // и которая возвращает новый элемент 147 | // - Действие - Делегат на функцию с одним параметром в который будет передан элемент, 148 | // и которая возвращает новый элемент 149 | // 150 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 151 | // значения будут доступны по обращению к ключу как к переменной. 152 | // При передачи действия в первом параметре, этот параметр игнорируется 153 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 154 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 155 | // При передачи действия в первом параметре, этот параметр игнорируется 156 | // 157 | // Возвращаемое значение: 158 | // ПроцессорКоллекций - Инстанс класса "ПроцессорКоллекций". 159 | // 160 | // Примеры: 161 | // // 1: 162 | // ПроцессорКоллекций.Обработать("Элемент -> Элемент + 1"); 163 | // 164 | // // 2: 165 | // Функция МояФункцияОбработки(Элемент) Экспорт 166 | // Возврат Элемент + 1; 167 | // КонецФункции 168 | // 169 | // ФункцияОбработки = Новый Действие(ЭтотОбъект, "МояФункцияОбработки"); 170 | // ПроцессорКоллекций.Обработать(ФункцияОбработки); 171 | // 172 | Функция Обработать(Знач ФункцияОбработки, Знач ДополнительныеПараметры = Неопределено) Экспорт 173 | ДобавитьШагВКонвейер(Новый ШагКонвейераОбработать(ФункцияОбработки, ДополнительныеПараметры, Отладка)); 174 | Возврат ЭтотОбъект; 175 | КонецФункции 176 | 177 | // Развернуть каждый элемент коллекции в процессор коллекций. 178 | // Позволяет расширить имеющуюся коллекцию. 179 | // Например, разворачивание массива массивов сделает новый массив, содержащий все элементы всех массивов. 180 | // Конвейерный метод. 181 | // 182 | // Параметры: 183 | // ФункцияРазворачивания - Строка - Лямбда выражение функция с одним параметром в который будет передан элемент, 184 | // и которая возвращает ПроцессорКоллекций из элемента 185 | // - Действие - Делегат на функцию с одним параметром в который будет передан элемент, 186 | // и которая возвращает ПроцессорКоллекций из элемента 187 | // 188 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 189 | // значения будут доступны по обращению к ключу как к переменной. 190 | // При передачи действия в первом параметре, этот параметр игнорируется 191 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 192 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 193 | // При передачи действия в первом параметре, этот параметр игнорируется 194 | // 195 | // Возвращаемое значение: 196 | // ПроцессорКоллекций - Инстанс класса "ПроцессорКоллекций". 197 | // 198 | // Примеры: 199 | // // 1: 200 | // ПроцессорКоллекций.Развернуть("Элемент -> ПроцессорыКоллекций.ИзСтроки(Элемент)"); 201 | // 202 | // // 2: 203 | // Функция МояФункцияРазворачивания(Элемент) Экспорт 204 | // Возврат ПроцессорыКоллекций.ИзСтроки(Элемент); 205 | // КонецФункции 206 | // 207 | // ФункцияРазворачивания = Новый Действие(ЭтотОбъект, "МояФункцияРазворачивания"); 208 | // ПроцессорКоллекций.Развернуть(ФункцияРазворачивания); 209 | // 210 | Функция Развернуть(Знач ФункцияРазворачивания, Знач ДополнительныеПараметры = Неопределено) Экспорт 211 | ДобавитьШагВКонвейер(Новый ШагКонвейераРазвернуть(ФункцияРазворачивания, ДополнительныеПараметры, Отладка)); 212 | Возврат ЭтотОбъект; 213 | КонецФункции 214 | 215 | // Фильтровать коллекцию по условию. 216 | // Конвейерный метод. 217 | // 218 | // Параметры: 219 | // ФункцияФильтрации - Строка - Лямбда выражение функция с одним параметром в который будет передан элемент, 220 | // и которая возвращает Булево, Истина если элемент проходит фильтр, ложь в противном случае 221 | // - Действие - Делегат на функцию с одним параметром в который будет передан элемент, 222 | // и которая возвращает Булево, Истина если элемент проходит фильтр, ложь в противном случае 223 | // 224 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 225 | // значения будут доступны по обращению к ключу как к переменной. 226 | // При передачи действия в первом параметре, этот параметр игнорируется 227 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 228 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 229 | // При передачи действия в первом параметре, этот параметр игнорируется 230 | // 231 | // Возвращаемое значение: 232 | // ПроцессорКоллекций - Инстанс класса "ПроцессорКоллекций". 233 | // 234 | // Примеры: 235 | // // 1: 236 | // ПроцессорКоллекций.Фильтровать("Элемент -> СтрДлина(Элемент) > 1"); 237 | // 238 | // // 2: 239 | // Функция МояФункцияФильтрации(Результат, ДополнительныеПараметры) Экспорт 240 | // Возврат СтрДлина(ДополнительныеПараметры.Элемент) > 1; 241 | // КонецФункции 242 | // 243 | // ФункцияФильтрации = Новый Действие(ЭтотОбъект, "МояФункцияФильтрации"); 244 | // ПроцессорКоллекций.Фильтровать(ФункцияФильтрации); 245 | // 246 | Функция Фильтровать(Знач ФункцияФильтрации, Знач ДополнительныеПараметры = Неопределено) Экспорт 247 | ДобавитьШагВКонвейер(Новый ШагКонвейераФильтровать(ФункцияФильтрации, ДополнительныеПараметры, Отладка)); 248 | Возврат ЭтотОбъект; 249 | КонецФункции 250 | 251 | // Сортировать элементы коллекции. 252 | // Конвейерный метод. 253 | // 254 | // Параметры: 255 | // ФункцияСравнения - Строка - Лямбда выражение функция с двумя параметрами в которые будут переданы два элемента, 256 | // и которая возвращает Число, 1 - если первый элемент больше, -1 если второй элемент больше, 0 - если элементы равны 257 | // - Действие - Делегат на функцию с двумя параметрами, в которые будут переданы два элемента, 258 | // и которая возвращает Число, 1 - если первый элемент больше, -1 если второй элемент больше, 0 - если элементы равны 259 | // - Неопределено - см. ПроцессорыКоллекций.СтандартнаяФункцияСравненияПрямойПорядок(), 260 | // проверка через ">", "<", "=" 261 | // 262 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 263 | // значения будут доступны по обращению к ключу как к переменной. 264 | // При передачи действия в первом параметре, этот параметр игнорируется 265 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 266 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 267 | // При передачи действия в первом параметре, этот параметр игнорируется 268 | // 269 | // Возвращаемое значение: 270 | // ПроцессорКоллекций - Инстанс класса "ПроцессорКоллекций". 271 | // 272 | // Примеры: 273 | // // 1: 274 | // ПроцессорКоллекций.Сортировать("(Первый, Второй) -> 275 | // | Если Первый > Второй Тогда Возврат 1; 276 | // | ИначеЕсли Второй > Первый Тогда Возврат -1; 277 | // | Иначе Возврат 0; 278 | // | КонецЕсли;" 279 | // ); 280 | // 281 | // // 2: 282 | // Функция МояФункцияСравнения(Первый, Второй) Экспорт 283 | // Если Первый > Второй Тогда 284 | // Возврат 1; 285 | // ИначеЕсли Второй > Первый Тогда 286 | // Возврат -1; 287 | // Иначе 288 | // Возврат 0; 289 | // КонецЕсли; 290 | // КонецФункции 291 | // 292 | // ФункцияСравнения = Новый Действие(ЭтотОбъект, "МояФункцияСравнения"); 293 | // ПроцессорКоллекций.Сортировать(ФункцияСравнения); 294 | // 295 | Функция Сортировать(Знач ФункцияСравнения = Неопределено, Знач ДополнительныеПараметры = Неопределено) Экспорт 296 | ДобавитьШагВКонвейер(Новый ШагКонвейераСортировать(ФункцияСравнения, ДополнительныеПараметры, Отладка)); 297 | Возврат ЭтотОбъект; 298 | КонецФункции 299 | 300 | // Сортировать элементы коллекции по выбранному полю. 301 | // Конвейерный метод. 302 | // 303 | // Параметры: 304 | // ИмяПоля - Строка - Имя поля элемента коллекции, по которому необходимо осуществлять сортировку. 305 | // 306 | // ФункцияСравнения - Строка - Лямбда выражение функция с двумя параметрами в которые будут переданы два элемента, 307 | // и которая возвращает Число, 1 - если первый элемент больше, -1 если второй элемент больше, 0 - если элементы равны 308 | // - Действие - Делегат на функцию с двумя параметрами, в которые будут переданы два элемента, 309 | // и которая возвращает Число, 1 - если первый элемент больше, -1 если второй элемент больше, 0 - если элементы равны 310 | // - Неопределено - см. ПроцессорыКоллекций.СтандартнаяФункцияСравненияПрямойПорядок(), 311 | // проверка через ">", "<", "=" 312 | // 313 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 314 | // значения будут доступны по обращению к ключу как к переменной. 315 | // При передачи действия в первом параметре, этот параметр игнорируется 316 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 317 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 318 | // При передачи действия в первом параметре, этот параметр игнорируется 319 | // 320 | // Возвращаемое значение: 321 | // ПроцессорКоллекций - Инстанс класса "ПроцессорКоллекций". 322 | // 323 | // Примеры: 324 | // // 1: 325 | // ПроцессорКоллекций.СортироватьПо("НомерСтроки", "(Первый, Второй) -> 326 | // | Если Первый > Второй Тогда Возврат 1; 327 | // | ИначеЕсли Второй > Первый Тогда Возврат -1; 328 | // | Иначе Возврат 0; 329 | // | КонецЕсли;" 330 | // ); 331 | // 332 | // // 2: 333 | // Функция МояФункцияСравнения(Первый, Второй) Экспорт 334 | // Если Первый > Второй Тогда 335 | // Возврат 1; 336 | // ИначеЕсли Второй > Первый Тогда 337 | // Возврат -1; 338 | // Иначе 339 | // Возврат 0; 340 | // КонецЕсли; 341 | // КонецФункции 342 | // 343 | // ФункцияСравнения = Новый Действие(ЭтотОбъект, "МояФункцияСравнения"); 344 | // ПроцессорКоллекций.СортироватьПо("НомерСтроки", ФункцияСравнения); 345 | // 346 | Функция СортироватьПо( 347 | Знач ИмяПоля, 348 | Знач ФункцияСравнения = Неопределено, 349 | Знач ДополнительныеПараметры = Неопределено) Экспорт 350 | 351 | ДобавитьШагВКонвейер(Новый ШагКонвейераСортировать(ФункцияСравнения, ДополнительныеПараметры, Отладка, ИмяПоля)); 352 | Возврат ЭтотОбъект; 353 | 354 | КонецФункции 355 | 356 | // Терминальные методы 357 | 358 | // Получить первый элемент. 359 | // Терминальный метод. 360 | // 361 | // Возвращаемое значение: 362 | // Произвольный - Первый элемент из коллекции. Если коллекция пуста, возвращает Неопределено. 363 | // 364 | Функция ПолучитьПервый() Экспорт 365 | ДобавитьШагВКонвейер(Новый ШагКонвейераПолучитьПервый()); 366 | Возврат ПройтиКонвейер(); 367 | КонецФункции 368 | 369 | // Получить коллекцию в виде массива. 370 | // Терминальный метод. 371 | // 372 | // Возвращаемое значение: 373 | // Массив - Массив элементов коллекции. 374 | // 375 | Функция ВМассив() Экспорт 376 | ДобавитьШагВКонвейер(Новый ШагКонвейераПолучить(Тип("Массив"))); 377 | Возврат ПройтиКонвейер(); 378 | КонецФункции 379 | 380 | // Получить коллекцию в виде строки. 381 | // Терминальный метод. 382 | // 383 | // Параметры: 384 | // РазделительСтрок - Строка - Используемый разделитель между элементами при конкатенации строк. 385 | // 386 | // Возвращаемое значение: 387 | // Строка - Элементы коллекции, соединенные в строку методом конкатенации. 388 | // 389 | Функция ВСтроку(РазделительСтрок = "") Экспорт 390 | ДобавитьШагВКонвейер(Новый ШагКонвейераВСтроку(РазделительСтрок)); 391 | Возврат ПройтиКонвейер(); 392 | КонецФункции 393 | 394 | // Получить количество элементов коллекции. 395 | // Терминальный метод. 396 | // 397 | // Возвращаемое значение: 398 | // Число - Количество элементов коллекции. 399 | // 400 | Функция Количество() Экспорт 401 | ДобавитьШагВКонвейер(Новый ШагКонвейераКоличество()); 402 | Возврат ПройтиКонвейер(); 403 | КонецФункции 404 | 405 | // Обработать каждый элемент коллекции и завершить работу процессора. 406 | // Терминальный метод. 407 | // 408 | // Параметры: 409 | // ФункцияОбработки - Строка - Лямбда выражение процедура с одним параметром в который будет передан элемент 410 | // - Действие - Делегат на процедуру с одним параметром в который будет передан элемент 411 | // 412 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 413 | // значения будут доступны по обращению к ключу как к переменной. 414 | // При передачи действия в первом параметре, этот параметр игнорируется 415 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 416 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 417 | // При передачи действия в первом параметре, этот параметр игнорируется 418 | // 419 | // Примеры: 420 | // // 1: 421 | // ПроцессорКоллекций.ДляКаждого("Элемент -> Сообщить(Элемент);"); 422 | // 423 | // // 2: 424 | // Процедура МояПроцедураОбработки(Элемент) Экспорт 425 | // Сообщить(Элемент); 426 | // КонецПроцедуры 427 | // 428 | // ПроцедураОбработки = Новый Действие(ЭтотОбъект, "МояПроцедураОбработки"); 429 | // ПроцессорКоллекций.ДляКаждого(ПроцедураОбработки); 430 | // 431 | Процедура ДляКаждого(Знач ФункцияОбработки, Знач ДополнительныеПараметры = Неопределено) Экспорт 432 | ДобавитьШагВКонвейер(Новый ШагКонвейераДляКаждого(ФункцияОбработки, ДополнительныеПараметры, Отладка)); 433 | ПройтиКонвейер(); 434 | КонецПроцедуры 435 | 436 | // Получить минимальный элемент. 437 | // Терминальный метод. 438 | // 439 | // Параметры: 440 | // ФункцияСравнения - Строка - Лямбда выражение функция с двумя параметрами в которые будут переданы два элемента, 441 | // и которая возвращает Число, 1 - если первый элемент больше, -1 если второй элемент больше, 0 - если элементы равны 442 | // - Действие - Делегат на функцию с двумя параметрами, в которые будут переданы два элемента, 443 | // и которая возвращает Число, 1 - если первый элемент больше, -1 если второй элемент больше, 0 - если элементы равны 444 | // - Неопределено - см. ПроцессорыКоллекций.СтандартнаяФункцияСравненияПрямойПорядок(), 445 | // проверка через ">", "<", "=" 446 | // 447 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 448 | // значения будут доступны по обращению к ключу как к переменной. 449 | // При передачи действия в первом параметре, этот параметр игнорируется 450 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 451 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 452 | // При передачи действия в первом параметре, этот параметр игнорируется 453 | // 454 | // Возвращаемое значение: 455 | // Произвольный - минимальный элемент коллекции. 456 | // 457 | // Примеры: 458 | // // 1: 459 | // ПроцессорКоллекций.Минимум(); 460 | // 461 | // // 2: 462 | // ПроцессорКоллекций.Минимум("(Первый, Второй) -> 463 | // | Если Первый > Второй Тогда Возврат 1; 464 | // | ИначеЕсли Второй > Первый Тогда Возврат -1; 465 | // | Иначе Возврат 0; 466 | // | КонецЕсли;" 467 | // ); 468 | // 469 | // // 3: 470 | // Функция МояФункцияСравнения(Первый, Второй) Экспорт 471 | // Если Первый > Второй Тогда 472 | // Возврат 1; 473 | // ИначеЕсли Второй > Первый Тогда 474 | // Возврат -1; 475 | // Иначе 476 | // Возврат 0; 477 | // КонецЕсли; 478 | // КонецФункции 479 | // 480 | // ФункцияСравнения = Новый Действие(ЭтотОбъект, "МояФункцияСравнения"); 481 | // ПроцессорКоллекций.Минимум(ФункцияСравнения); 482 | // 483 | Функция Минимум(Знач ФункцияСравнения = Неопределено, Знач ДополнительныеПараметры = Неопределено) Экспорт 484 | 485 | ДобавитьШагВКонвейер(Новый ШагКонвейераСортировать(ФункцияСравнения, ДополнительныеПараметры, Отладка)); 486 | ДобавитьШагВКонвейер(Новый ШагКонвейераПолучитьПервый()); 487 | 488 | Возврат ПройтиКонвейер(); 489 | 490 | КонецФункции 491 | 492 | // Получить максимальный элемент. 493 | // Терминальный метод. 494 | // 495 | // Параметры: 496 | // ФункцияСравнения - Строка - Лямбда выражение функция с двумя параметрами в которые будут переданы два элемента, 497 | // и которая возвращает Число, 1 - если первый элемент больше, -1 если второй элемент больше, 0 - если элементы равны 498 | // - Действие - Делегат на функцию с двумя параметрами, в которые будут переданы два элемента, 499 | // и которая возвращает Число, 1 - если первый элемент больше, -1 если второй элемент больше, 0 - если элементы равны 500 | // - Неопределено - см. ПроцессорыКоллекций.СтандартнаяФункцияСравненияПрямойПорядок(), 501 | // проверка через ">", "<", "=" 502 | // 503 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 504 | // значения будут доступны по обращению к ключу как к переменной. 505 | // При передачи действия в первом параметре, этот параметр игнорируется 506 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 507 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 508 | // При передачи действия в первом параметре, этот параметр игнорируется 509 | // 510 | // Возвращаемое значение: 511 | // Произвольный - максимальный элемент коллекции. 512 | // 513 | // Примеры: 514 | // // 1: 515 | // ПроцессорКоллекций.Максимум(); 516 | // 517 | // // 2: 518 | // ПроцессорКоллекций.Максимум("(Первый, Второй) -> 519 | // | Если Первый > Второй Тогда Возврат 1; 520 | // | ИначеЕсли Второй > Первый Тогда Возврат -1; 521 | // | Иначе Возврат 0; 522 | // | КонецЕсли;" 523 | // ); 524 | // 525 | // // 3: 526 | // Функция МояФункцияСравнения(Первый, Второй) Экспорт 527 | // Если Первый > Второй Тогда 528 | // Возврат 1; 529 | // ИначеЕсли Второй > Первый Тогда 530 | // Возврат -1; 531 | // Иначе 532 | // Возврат 0; 533 | // КонецЕсли; 534 | // КонецФункции 535 | // 536 | // ФункцияСравнения = Новый Действие(ЭтотОбъект, "МояФункцияСравнения"); 537 | // ПроцессорКоллекций.Максимум(ФункцияСравнения); 538 | // 539 | Функция Максимум(Знач ФункцияСравнения = Неопределено, Знач ДополнительныеПараметры = Неопределено) Экспорт 540 | 541 | Сортировка = Новый ШагКонвейераСортировать(ФункцияСравнения, ДополнительныеПараметры, Отладка); 542 | Сортировка.Инвертировать(); 543 | 544 | ДобавитьШагВКонвейер(Сортировка); 545 | ДобавитьШагВКонвейер(Новый ШагКонвейераПолучитьПервый()); 546 | 547 | Возврат ПройтиКонвейер(); 548 | 549 | КонецФункции 550 | 551 | // Выполнить агрегатную функцию над элементами коллекции. 552 | // Терминальный метод. 553 | // 554 | // Параметры: 555 | // ФункцияСокращения - Строка - Лямбда выражение функция с двумя параметрами в которые будут переданы 556 | // результат аккумулятор и очередной элемент коллекции, и которая возвращает новое значение результата 557 | // - Действие - Делегат на функцию с двумя параметрами в которые будут переданы 558 | // результат аккумулятор и очередной элемент коллекции, и которая возвращает новое значение результата 559 | // 560 | // НачальноеЗначение - Произвольный - начальное значение, передаваемое в функцию сокращения в параметр "Результат" 561 | // 562 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 563 | // значения будут доступны по обращению к ключу как к переменной. 564 | // При передачи действия в первом параметре, этот параметр игнорируется 565 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 566 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 567 | // При передачи действия в первом параметре, этот параметр игнорируется 568 | // 569 | // Возвращаемое значение: 570 | // Произвольный - результат работы агрегатной функции. 571 | // 572 | // Примеры: 573 | // 2: 574 | // ПроцессорКоллекций.Сократить("Результат, Элемент -> Результат + Элемент", 0); 575 | // 576 | // 2: 577 | // Функция МояФункцияСокращения(Результат, Элемент) Экспорт 578 | // Возврат Результат + Элемент; 579 | // КонецФункции 580 | // 581 | // ФункцияСокращения = Новый Действие(ЭтотОбъект, "МояФункцияСокращения"); 582 | // ПроцессорКоллекций.Сократить(ФункцияСокращения); 583 | // 584 | Функция Сократить(Знач ФункцияСокращения, 585 | Знач НачальноеЗначение = Неопределено, 586 | Знач ДополнительныеПараметры = Неопределено) Экспорт 587 | 588 | ДобавитьШагВКонвейер( 589 | Новый ШагКонвейераСократить(ФункцияСокращения, ДополнительныеПараметры, НачальноеЗначение, Отладка) 590 | ); 591 | Возврат ПройтиКонвейер(); 592 | 593 | КонецФункции 594 | 595 | // Получить коллекцию в виде объекта заданного типа. 596 | // Терминальный метод. 597 | // 598 | // Параметры: 599 | // ТипРезультата - Тип - Тип, в котором необходимо вернуть коллекцию. 600 | // 601 | // Возвращаемое значение: 602 | // Произвольный - Коллекция в виде объекта нужного типа. 603 | // 604 | Функция Получить(ТипРезультата) Экспорт 605 | ДобавитьШагВКонвейер(Новый ШагКонвейераПолучить(ТипРезультата, КэшКолонок)); 606 | Возврат ПройтиКонвейер(); 607 | КонецФункции 608 | 609 | // Проверить, что хотя бы один элемент коллекции удовлетворяет условию в функции сравнения. 610 | // Терминальный метод. 611 | // 612 | // Параметры: 613 | // ФункцияСравнения - Строка - Лямбда выражение функция с одним параметром в который будет передан элемент, 614 | // и которая возвращает Булево, Истина если элемент проходит фильтр, ложь в противном случае 615 | // - Действие - Делегат на функцию с одним параметром в который будет передан элемент, 616 | // и которая возвращает Булево, Истина если элемент проходит фильтр, ложь в противном случае 617 | // 618 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 619 | // значения будут доступны по обращению к ключу как к переменной. 620 | // При передачи действия в первом параметре, этот параметр игнорируется 621 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 622 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 623 | // При передачи действия в первом параметре, этот параметр игнорируется 624 | // 625 | // Возвращаемое значение: 626 | // Булево - Истина, если минимум один из элементов коллекции удовлетворяет условию Функции сравнения. 627 | // В обратном случае возвращает Ложь. 628 | // Если коллекция пустая, возвращает Ложь. 629 | // 630 | Функция ЛюбойСоответствует(Знач ФункцияСравнения, Знач ДополнительныеПараметры = Неопределено) Экспорт 631 | 632 | ДобавитьШагВКонвейер(Новый ШагКонвейераЛюбойСоответствует(ФункцияСравнения, ДополнительныеПараметры, Отладка)); 633 | ДобавитьШагВКонвейер(Новый ШагКонвейераБарьерВернутьЗначение(Ложь)); 634 | 635 | Возврат ПройтиКонвейер(); 636 | 637 | КонецФункции 638 | 639 | // Проверить, что все элементы коллекции удовлетворяют условию в функции сравнения. 640 | // Терминальный метод. 641 | // 642 | // Параметры: 643 | // ФункцияСравнения - Строка - Лямбда выражение функция с одним параметром в который будет передан элемент, 644 | // и которая возвращает Булево, Истина если элемент проходит фильтр, ложь в противном случае 645 | // - Действие - Делегат на функцию с одним параметром в который будет передан элемент, 646 | // и которая возвращает Булево, Истина если элемент проходит фильтр, ложь в противном случае 647 | // 648 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 649 | // значения будут доступны по обращению к ключу как к переменной. 650 | // При передачи действия в первом параметре, этот параметр игнорируется 651 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 652 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 653 | // При передачи действия в первом параметре, этот параметр игнорируется 654 | // 655 | // Возвращаемое значение: 656 | // Булево - Истина, если все элементы коллекции удовлетворяют условию Функции сравнения. 657 | // В обратном случае возвращает Ложь. 658 | // Если коллекция пустая, возвращает Истина. 659 | // 660 | Функция ВсеСоответствуют(Знач ФункцияСравнения, Знач ДополнительныеПараметры = Неопределено) Экспорт 661 | 662 | Фильтр = Новый ШагКонвейераЛюбойСоответствует(ФункцияСравнения, ДополнительныеПараметры, Отладка); 663 | Фильтр.Инвертировать(); 664 | 665 | ДобавитьШагВКонвейер(Фильтр); 666 | ДобавитьШагВКонвейер(Новый ШагКонвейераБарьерВернутьЗначение(Истина)); 667 | 668 | Возврат ПройтиКонвейер(); 669 | 670 | КонецФункции 671 | 672 | // Проверить, что все элементы коллекции не удовлетворяют условию в функции сравнения. 673 | // Терминальный метод. 674 | // 675 | // Параметры: 676 | // ФункцияСравнения - Строка - Лямбда выражение функция с одним параметром в который будет передан элемент, 677 | // и которая возвращает Булево, Истина если элемент проходит фильтр, ложь в противном случае 678 | // - Действие - Делегат на функцию с одним параметром в который будет передан элемент, 679 | // и которая возвращает Булево, Истина если элемент проходит фильтр, ложь в противном случае 680 | // 681 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 682 | // значения будут доступны по обращению к ключу как к переменной. 683 | // При передачи действия в первом параметре, этот параметр игнорируется 684 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 685 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 686 | // При передачи действия в первом параметре, этот параметр игнорируется 687 | // 688 | // Возвращаемое значение: 689 | // Булево - Истина, если все элементы коллекции не удовлетворяют условию Функции сравнения. 690 | // В обратном случае возвращает Ложь. 691 | // Если коллекция пустая, возвращает Истина. 692 | // 693 | Функция ВсеНеСоответствуют(Знач ФункцияСравнения, Знач ДополнительныеПараметры = Неопределено) Экспорт 694 | 695 | Фильтр = Новый ШагКонвейераЛюбойСоответствует(ФункцияСравнения, ДополнительныеПараметры, Отладка); 696 | Фильтр.Инвертировать(Истина); 697 | 698 | ДобавитьШагВКонвейер(Фильтр); 699 | ДобавитьШагВКонвейер(Новый ШагКонвейераБарьерВернутьЗначение(Истина)); 700 | 701 | Возврат ПройтиКонвейер(); 702 | 703 | КонецФункции 704 | 705 | // Служебные процедуры и функции 706 | 707 | Процедура ДобавитьШагВКонвейер(ШагКонвейера) 708 | 709 | Если ШагКонвейера.Барьерный() Тогда 710 | 711 | Если Не Конвейер.Получить(НомерПроходаКонвейера) = Неопределено Тогда 712 | НомерПроходаКонвейера = НомерПроходаКонвейера + 1; 713 | КонецЕсли; 714 | 715 | Конвейер.Вставить(НомерПроходаКонвейера, ШагКонвейера); 716 | 717 | Иначе 718 | 719 | Если Не ТипЗнч(Конвейер.Получить(НомерПроходаКонвейера)) = Тип("Массив") 720 | И Не Конвейер.Получить(НомерПроходаКонвейера) = Неопределено Тогда 721 | НомерПроходаКонвейера = НомерПроходаКонвейера + 1; 722 | КонецЕсли; 723 | 724 | Если Конвейер.Получить(НомерПроходаКонвейера) = Неопределено Тогда 725 | Конвейер.Вставить(НомерПроходаКонвейера, Новый Массив); 726 | КонецЕсли; 727 | 728 | Конвейер.Получить(НомерПроходаКонвейера).Добавить(ШагКонвейера); 729 | 730 | КонецЕсли; 731 | 732 | КонецПроцедуры 733 | 734 | Функция ПройтиКонвейер() 735 | 736 | Для Проход = 1 По НомерПроходаКонвейера Цикл 737 | 738 | ШагПроходаКонвейера = Конвейер.Получить(Проход); 739 | 740 | Если ТипЗнч(ШагПроходаКонвейера) <> Тип("Массив") Тогда // Барьер 741 | 742 | Результат = ШагПроходаКонвейера.Принять(Коллекция); 743 | 744 | Если Результат.Действие = ДействияКонвейера.ЗаменитьКоллекцию Тогда 745 | Коллекция = Результат.Коллекция; 746 | ИначеЕсли Результат.Действие = ДействияКонвейера.ВернутьЗначение Тогда 747 | ОчиститьКонвейер(); 748 | Возврат Результат.Значение; 749 | КонецЕсли; 750 | 751 | Иначе 752 | 753 | НоваяКоллекция = Новый Массив; 754 | 755 | Для каждого ЭлементКоллекции Из Коллекция Цикл 756 | 757 | Для каждого ШагКонвейера Из ШагПроходаКонвейера Цикл 758 | 759 | Результат = ШагКонвейера.Принять(ЭлементКоллекции); 760 | 761 | Если Результат.Действие = ДействияКонвейера.ПропуститьЭлемент 762 | Или Результат.Действие = ДействияКонвейера.ПрекратитьОбход Тогда 763 | Прервать; 764 | ИначеЕсли Результат.Действие = ДействияКонвейера.ЗаменитьЭлемент Тогда 765 | ЭлементКоллекции = Результат.Элемент; 766 | ИначеЕсли Результат.Действие = ДействияКонвейера.ВернутьЗначение Тогда 767 | ОчиститьКонвейер(); 768 | Возврат Результат.Значение; 769 | КонецЕсли 770 | 771 | КонецЦикла; 772 | 773 | Если Результат.Действие = ДействияКонвейера.ПропуститьЭлемент Тогда 774 | Продолжить; 775 | ИначеЕсли Результат.Действие = ДействияКонвейера.ПрекратитьОбход Тогда 776 | Прервать; 777 | КонецЕсли; 778 | 779 | НоваяКоллекция.Добавить(ЭлементКоллекции); 780 | 781 | КонецЦикла; 782 | 783 | Коллекция = НоваяКоллекция; 784 | 785 | КонецЕсли; 786 | 787 | КонецЦикла; 788 | 789 | ОчиститьКонвейер(); 790 | 791 | КонецФункции 792 | 793 | Процедура ОчиститьКонвейер() 794 | 795 | Для Каждого КлючИЗначение Из Конвейер Цикл 796 | Если ТипЗнч(КлючИЗначение.Значение) = Тип("Массив") Тогда 797 | Для каждого ШагКонвейера Из КлючИЗначение.Значение Цикл 798 | ШагКонвейера.Деструктор(); 799 | КонецЦикла; 800 | Иначе 801 | КлючИЗначение.Значение.Деструктор(); 802 | КонецЕсли; 803 | КонецЦикла; 804 | 805 | Конвейер = Новый Соответствие; 806 | НомерПроходаКонвейера = 1; 807 | 808 | КонецПроцедуры 809 | 810 | Процедура ПриСозданииОбъекта() 811 | 812 | Отладка = ЗначениеЗаполнено(ПолучитьПеременнуюСреды("OSCRIPT_FLUENT_DEBUG")); 813 | 814 | Конвейер = Новый Соответствие; 815 | 816 | НомерПроходаКонвейера = 1; 817 | 818 | Лог = Логирование.ПолучитьЛог("oscript.lib.stream"); 819 | 820 | КонецПроцедуры 821 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # fluent 2 | 3 | [![Build Status](https://travis-ci.org/nixel2007/oscript-fluent.svg?branch=develop)](https://travis-ci.org/nixel2007/oscript-fluent) 4 | [![Quality Gate](https://sonar.openbsl.ru/api/project_badges/measure?project=oscript-fluent&metric=alert_status)](https://sonar.openbsl.ru/dashboard?id=oscript-fluent) 5 | [![Maintainability](https://sonar.openbsl.ru/api/project_badges/measure?project=oscript-fluent&metric=sqale_rating)](https://sonar.openbsl.ru/dashboard?id=oscript-fluent) 6 | [![Coverage](https://sonar.openbsl.ru/api/project_badges/measure?project=oscript-fluent&metric=coverage)](https://sonar.openbsl.ru/dashboard?id=oscript-fluent) 7 | 8 | Библиотека быстрой обработки коллекций. 9 | 10 | Позволяет в "текучем" стиле обрабатывать коллекции - фильтровать, упорядочивать, выполнять операции над элементы, получать результат в виде заданного типа и др. 11 | 12 | ## Возможности 13 | 14 | Поддержка строк, массивов, таблиц значений, деревьев значений. 15 | > Структуры и соответствия incoming 16 | 17 | Конвейерные методы: 18 | 19 | * Первые 20 | * Пропустить 21 | * Различные 22 | * Обработать 23 | * Развернуть 24 | * Фильтровать 25 | * Сортировать 26 | * СортироватьПо 27 | 28 | Терминальные методы: 29 | 30 | * ПолучитьПервый 31 | * ВМассив 32 | * ВСтроку 33 | * Количество 34 | * ДляКаждого 35 | * Минимум 36 | * Максимум 37 | * Сократить 38 | * Получить 39 | * ЛюбойСоответствует 40 | * ВсеСоответствуют 41 | * ВсеНеСоответствуют 42 | 43 | Функции сравнения, фильтрации, обработки могут задаваться с помощью: 44 | 45 | * Строк библиотека [lambdas](https://github.com/oscript-library/lambdas) 46 | * Действие 47 | 48 | Библиотека помимо конструктора класса `ПроцессорКоллекций` содержит вспомогательный модуль, включающий: 49 | 50 | * построитель процессора коллекций `ИзКоллекции()` 51 | * построитель процессора коллекций `ИзСтроки()` 52 | * построитель процессора коллекций `ИзНабора()` 53 | * `СтандартнаяФункцияСравненияПрямойПорядок()` - типовой `comparator`, возвращающий результат сравнения как `1`, `0`, `-1` 54 | 55 | ## Примеры работы 56 | 57 | ```bsl 58 | Массив = Новый Массив; 59 | Массив.Добавить(3); 60 | Массив.Добавить(4); 61 | Массив.Добавить(7); 62 | Массив.Добавить(5); 63 | Массив.Добавить(1); 64 | Массив.Добавить(0); 65 | 66 | Результат = ПроцессорыКоллекций.ИзКоллекции(Массив) 67 | .Пропустить(1) 68 | .Фильтровать("Элемент -> Элемент >= 5") 69 | .Первые(2) 70 | .Обработать("Элемент -> Элемент + 1") 71 | .Получить(Тип("Массив")); 72 | 73 | // На выходе массив [8, 6] 74 | ``` 75 | 76 | Тоже самое с помощью `Действие`: 77 | 78 | ```bsl 79 | Функция ОбработчикФильтрации(Элемент) Экспорт 80 | Возврат Элемент >= 5; 81 | КонецФункции 82 | 83 | Функция ОбработчикОбработки(Элемент) Экспорт 84 | 85 | Результат = Элемент + 1; 86 | 87 | Сообщить("Я - операция map, и это мое послание миру: элемент " + Элемент + " превратился в " + Результат); 88 | 89 | Возврат Результат; 90 | 91 | КонецФункции 92 | 93 | ФункцияФильтрации = Новый Действие(ЭтотОбъект, "ОбработчикФильтрации"); 94 | ФункцияОбработки = Новый Действие(ЭтотОбъект, "ОбработчикОбработки"); 95 | 96 | Результат = ПроцессорыКоллекций.ИзКоллекции(Массив) 97 | .Пропустить(1) 98 | .Фильтровать(ФункцияФильтрации) 99 | .Первые(2) 100 | .Обработать(ФункцияОбработки) 101 | .Получить(Тип("Массив")); 102 | ``` 103 | 104 | ```bsl 105 | Массив = Новый Массив; 106 | Массив.Добавить(4); 107 | Массив.Добавить(2); 108 | Массив.Добавить(2); 109 | Массив.Добавить(3); 110 | Массив.Добавить(3); 111 | Массив.Добавить(3); 112 | 113 | ПроцессорКоллекций = ПроцессорыКоллекций.ИзКоллекции(Массив); 114 | ПроцессорКоллекций 115 | .Различные() 116 | .Сортировать() 117 | .ДляКаждого("Элемент -> Сообщить(Элемент)"); 118 | 119 | // На выходе сообщения в консоль: 120 | // 2 121 | // 3 122 | // 4 123 | ``` 124 | 125 | ```bsl 126 | Строка = "Я 127 | |строка 128 | |многострочная"; 129 | 130 | ПроцессорыКоллекций 131 | .ИзСтроки(Строка, Символы.ПС) 132 | .Фильтровать("Элемент -> СтрДлина(Элемент) > 1") 133 | .ДляКаждого("Элемент -> Сообщить(Элемент)"); 134 | 135 | // На выходе сообщения в консоль: 136 | // многострочная 137 | // строка 138 | ``` 139 | 140 | Больше примеров работы в каталогах `examples` и `tests`. 141 | 142 | ## Публичный интерфейс 143 | 144 | ### Класс ПроцессорКоллекций 145 | 146 | > Общее API 147 | 148 | #### УстановитьКоллекцию 149 | 150 | ```bsl 151 | // Устанавливает коллекцию для обработки Процессора коллекций. 152 | // 153 | // Параметры: 154 | // НоваяКоллекция - Массив, ТаблицаЗначений, ДеревоЗначений - Коллекция, устанавливаемая в процессор. 155 | // 156 | Процедура УстановитьКоллекцию(НоваяКоллекция) 157 | ``` 158 | 159 | #### Отладка 160 | 161 | ```bsl 162 | // Включает возможность отладки. Достигается сохранением текста модуля во временный файл. 163 | // 164 | // Возвращаемое значение: 165 | // ПроцессорКоллекций - Ссылка на текущий инстанс ПроцессорКоллекций 166 | // 167 | Функция Отладка(Включена = Истина) 168 | ``` 169 | 170 | > Конвейерные методы 171 | 172 | #### Первые 173 | 174 | ```bsl 175 | // Получить первые N элементов. 176 | // Конвейерный метод. 177 | // 178 | // Параметры: 179 | // Количество - Число - Число отбираемых элементов. 180 | // 181 | // Возвращаемое значение: 182 | // ПроцессорКоллекций - Инстанс класса "ПроцессорКоллекций". 183 | // 184 | Функция Первые(Количество) 185 | ``` 186 | 187 | #### Пропустить 188 | 189 | ```bsl 190 | // Пропустить первые N элементов. 191 | // Конвейерный метод. 192 | // 193 | // Параметры: 194 | // Количество - Число - Число пропускаемых элементов. 195 | // 196 | // Возвращаемое значение: 197 | // ПроцессорКоллекций - Инстанс класса "ПроцессорКоллекций". 198 | // 199 | Функция Пропустить(Количество) 200 | ``` 201 | 202 | #### Различные 203 | 204 | ```bsl 205 | // Выбрать различные элементы. 206 | // Конвейерный метод. 207 | // 208 | // Параметры: 209 | // ФункцияРавенства - Строка - Лямбда выражение функция с двумя параметрами в которые будут переданы два элемента, 210 | // и которая возвращает Булево, Истина если элементы равны, Ложь в противном случае 211 | // - Действие - Делегат на функцию с двумя параметрами, в которые будут переданы два элемента, 212 | // и которая возвращает Булево, Истина если элементы равны, Ложь в противном случае 213 | // - Неопределено - см. ПроцессорыКоллекций.СтандартнаяФункцияРавенства(), 214 | // проверка "Элемент1 = Элемент2" 215 | // 216 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 217 | // значения будут доступны по обращению к ключу как к переменной. 218 | // При передачи действия в первом параметре, этот параметр игнорируется 219 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 220 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 221 | // При передачи действия в первом параметре, этот параметр игнорируется 222 | // 223 | // Возвращаемое значение: 224 | // ПроцессорКоллекций - Инстанс класса "ПроцессорКоллекций". 225 | // 226 | // Примеры: 227 | // 228 | // ПроцессорКоллекций = ПроцессорыКоллекций.ИзНабора( 229 | // Новый Структура("Имя, Возраст", "Вася", 25), 230 | // Новый Структура("Имя, Возраст", "Петя", 27), 231 | // Новый Структура("Имя, Возраст", "Ваня", 25) 232 | // ); 233 | // 234 | // // 1: 235 | // ПроцессорКоллекций.Различные("(ЧеловекПервый, ЧеловекВторой) -> ЧеловекПервый.Возраст = ЧеловекВторой.Возраст"); 236 | // 237 | // // В коллекции останутся: Вася(25) и Петя(27) 238 | // 239 | // // 2: 240 | // Функция МояФункцияФункцияРавенства(ЭлементПервый, ЭлементВторой) Экспорт 241 | // Возврат ЧеловекПервый.Возраст = ЧеловекВторой.Возраст; 242 | // КонецФункции 243 | // 244 | // ПроцессорКоллекций.Различные(Новый Действие(ЭтотОбъект, "МояФункцияФункцияРавенства")); 245 | // 246 | // // В коллекции останутся: Вася(25) и Петя(27) 247 | // 248 | Функция Различные(Знач ФункцияРавенства = Неопределено, Знач ДополнительныеПараметры = Неопределено) 249 | ``` 250 | 251 | #### Обработать 252 | 253 | ```bsl 254 | // Обработать каждый элемент коллекции. 255 | // Конвейерный метод. 256 | // 257 | // Параметры: 258 | // ФункцияОбработки - Строка - Лямбда выражение функция с одним параметром в который будет передан элемент, 259 | // и которая возвращает новый элемент 260 | // - Действие - Делегат на функцию с одним параметром в который будет передан элемент, 261 | // и которая возвращает новый элемент 262 | // 263 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 264 | // значения будут доступны по обращению к ключу как к переменной. 265 | // При передачи действия в первом параметре, этот параметр игнорируется 266 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 267 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 268 | // При передачи действия в первом параметре, этот параметр игнорируется 269 | // 270 | // Возвращаемое значение: 271 | // ПроцессорКоллекций - Инстанс класса "ПроцессорКоллекций". 272 | // 273 | // Примеры: 274 | // // 1: 275 | // ПроцессорКоллекций.Обработать("Элемент -> Элемент + 1"); 276 | // 277 | // // 2: 278 | // Функция МояФункцияОбработки(Элемент) Экспорт 279 | // Возврат Элемент + 1; 280 | // КонецФункции 281 | // 282 | // ФункцияОбработки = Новый Действие(ЭтотОбъект, "МояФункцияОбработки"); 283 | // ПроцессорКоллекций.Обработать(ФункцияОбработки); 284 | // 285 | Функция Обработать(Знач ФункцияОбработки, Знач ДополнительныеПараметры = Неопределено) 286 | ``` 287 | 288 | #### Развернуть 289 | 290 | ```bsl 291 | // Развернуть каждый элемент коллекции в процессор коллекций. 292 | // Позволяет расширить имеющуюся коллекцию. 293 | // Например, разворачивание массива массивов сделает новый массив, содержащий все элементы всех массивов. 294 | // Конвейерный метод. 295 | // 296 | // Параметры: 297 | // ФункцияРазворачивания - Строка - Лямбда выражение функция с одним параметром в который будет передан элемент, 298 | // и которая возвращает ПроцессорКоллекций из элемента 299 | // - Действие - Делегат на функцию с одним параметром в который будет передан элемент, 300 | // и которая возвращает ПроцессорКоллекций из элемента 301 | // 302 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 303 | // значения будут доступны по обращению к ключу как к переменной. 304 | // При передачи действия в первом параметре, этот параметр игнорируется 305 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 306 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 307 | // При передачи действия в первом параметре, этот параметр игнорируется 308 | // 309 | // Возвращаемое значение: 310 | // ПроцессорКоллекций - Инстанс класса "ПроцессорКоллекций". 311 | // 312 | // Примеры: 313 | // // 1: 314 | // ПроцессорКоллекций.Развернуть("Элемент -> ПроцессорыКоллекций.ИзСтроки(Элемент)"); 315 | // 316 | // // 2: 317 | // Функция МояФункцияРазворачивания(Элемент) Экспорт 318 | // Возврат ПроцессорыКоллекций.ИзСтроки(Элемент); 319 | // КонецФункции 320 | // 321 | // ФункцияРазворачивания = Новый Действие(ЭтотОбъект, "МояФункцияРазворачивания"); 322 | // ПроцессорКоллекций.Развернуть(ФункцияРазворачивания); 323 | // 324 | Функция Развернуть(Знач ФункцияРазворачивания, Знач ДополнительныеПараметры = Неопределено) 325 | ``` 326 | 327 | #### Фильтровать 328 | 329 | ```bsl 330 | // Фильтровать коллекцию по условию. 331 | // Конвейерный метод. 332 | // 333 | // Параметры: 334 | // ФункцияФильтрации - Строка - Лямбда выражение функция с одним параметром в который будет передан элемент, 335 | // и которая возвращает Булево, Истина если элемент проходит фильтр, ложь в противном случае 336 | // - Действие - Делегат на функцию с одним параметром в который будет передан элемент, 337 | // и которая возвращает Булево, Истина если элемент проходит фильтр, ложь в противном случае 338 | // 339 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 340 | // значения будут доступны по обращению к ключу как к переменной. 341 | // При передачи действия в первом параметре, этот параметр игнорируется 342 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 343 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 344 | // При передачи действия в первом параметре, этот параметр игнорируется 345 | // 346 | // Возвращаемое значение: 347 | // ПроцессорКоллекций - Инстанс класса "ПроцессорКоллекций". 348 | // 349 | // Примеры: 350 | // // 1: 351 | // ПроцессорКоллекций.Фильтровать("Элемент -> СтрДлина(Элемент) > 1"); 352 | // 353 | // // 2: 354 | // Функция МояФункцияФильтрации(Результат, ДополнительныеПараметры) Экспорт 355 | // Возврат СтрДлина(ДополнительныеПараметры.Элемент) > 1; 356 | // КонецФункции 357 | // 358 | // ФункцияФильтрации = Новый Действие(ЭтотОбъект, "МояФункцияФильтрации"); 359 | // ПроцессорКоллекций.Фильтровать(ФункцияФильтрации); 360 | // 361 | Функция Фильтровать(Знач ФункцияФильтрации, Знач ДополнительныеПараметры = Неопределено) 362 | ``` 363 | 364 | #### Сортировать 365 | 366 | ```bsl 367 | // Сортировать элементы коллекции. 368 | // Конвейерный метод. 369 | // 370 | // Параметры: 371 | // ФункцияСравнения - Строка - Лямбда выражение функция с двумя параметрами в которые будут переданы два элемента, 372 | // и которая возвращает Число, 1 - если первый элемент больше, -1 если второй элемент больше, 0 - если элементы равны 373 | // - Действие - Делегат на функцию с двумя параметрами, в которые будут переданы два элемента, 374 | // и которая возвращает Число, 1 - если первый элемент больше, -1 если второй элемент больше, 0 - если элементы равны 375 | // - Неопределено - см. ПроцессорыКоллекций.СтандартнаяФункцияСравненияПрямойПорядок(), 376 | // проверка через ">", "<", "=" 377 | // 378 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 379 | // значения будут доступны по обращению к ключу как к переменной. 380 | // При передачи действия в первом параметре, этот параметр игнорируется 381 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 382 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 383 | // При передачи действия в первом параметре, этот параметр игнорируется 384 | // 385 | // Возвращаемое значение: 386 | // ПроцессорКоллекций - Инстанс класса "ПроцессорКоллекций". 387 | // 388 | // Примеры: 389 | // // 1: 390 | // ПроцессорКоллекций.Сортировать("(Первый, Второй) -> 391 | // | Если Первый > Второй Тогда Возврат 1; 392 | // | ИначеЕсли Второй > Первый Тогда Возврат -1; 393 | // | Иначе Возврат 0; 394 | // | КонецЕсли;" 395 | // ); 396 | // 397 | // // 2: 398 | // Функция МояФункцияСравнения(Первый, Второй) Экспорт 399 | // Если Первый > Второй Тогда 400 | // Возврат 1; 401 | // ИначеЕсли Второй > Первый Тогда 402 | // Возврат -1; 403 | // Иначе 404 | // Возврат 0; 405 | // КонецЕсли; 406 | // КонецФункции 407 | // 408 | // ФункцияСравнения = Новый Действие(ЭтотОбъект, "МояФункцияСравнения"); 409 | // ПроцессорКоллекций.Сортировать(ФункцияСравнения); 410 | // 411 | Функция Сортировать(Знач ФункцияСравнения = Неопределено, Знач ДополнительныеПараметры = Неопределено) 412 | ``` 413 | 414 | #### СортироватьПо 415 | 416 | ```bsl 417 | // Сортировать элементы коллекции по выбранному полю. 418 | // Конвейерный метод. 419 | // 420 | // Параметры: 421 | // ИмяПоля - Строка - Имя поля элемента коллекции, по которому необходимо осуществлять сортировку. 422 | // 423 | // ФункцияСравнения - Строка - Лямбда выражение функция с двумя параметрами в которые будут переданы два элемента, 424 | // и которая возвращает Число, 1 - если первый элемент больше, -1 если второй элемент больше, 0 - если элементы равны 425 | // - Действие - Делегат на функцию с двумя параметрами, в которые будут переданы два элемента, 426 | // и которая возвращает Число, 1 - если первый элемент больше, -1 если второй элемент больше, 0 - если элементы равны 427 | // - Неопределено - см. ПроцессорыКоллекций.СтандартнаяФункцияСравненияПрямойПорядок(), 428 | // проверка через ">", "<", "=" 429 | // 430 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 431 | // значения будут доступны по обращению к ключу как к переменной. 432 | // При передачи действия в первом параметре, этот параметр игнорируется 433 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 434 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 435 | // При передачи действия в первом параметре, этот параметр игнорируется 436 | // 437 | // Возвращаемое значение: 438 | // ПроцессорКоллекций - Инстанс класса "ПроцессорКоллекций". 439 | // 440 | // Примеры: 441 | // // 1: 442 | // ПроцессорКоллекций.СортироватьПо("НомерСтроки", "(Первый, Второй) -> 443 | // | Если Первый > Второй Тогда Возврат 1; 444 | // | ИначеЕсли Второй > Первый Тогда Возврат -1; 445 | // | Иначе Возврат 0; 446 | // | КонецЕсли;" 447 | // ); 448 | // 449 | // // 2: 450 | // Функция МояФункцияСравнения(Первый, Второй) Экспорт 451 | // Если Первый > Второй Тогда 452 | // Возврат 1; 453 | // ИначеЕсли Второй > Первый Тогда 454 | // Возврат -1; 455 | // Иначе 456 | // Возврат 0; 457 | // КонецЕсли; 458 | // КонецФункции 459 | // 460 | // ФункцияСравнения = Новый Действие(ЭтотОбъект, "МояФункцияСравнения"); 461 | // ПроцессорКоллекций.СортироватьПо("НомерСтроки", ФункцияСравнения); 462 | // 463 | Функция СортироватьПо(Знач ИмяПоля, Знач ФункцияСравнения = Неопределено, Знач ДополнительныеПараметры = Неопределено) 464 | ``` 465 | 466 | > Терминальные методы 467 | 468 | #### ПолучитьПервый 469 | 470 | ```bsl 471 | // Получить первый элемент. 472 | // Терминальный метод. 473 | // 474 | // Возвращаемое значение: 475 | // Произвольный - Первый элемент из коллекции. Если коллекция пуста, возвращает Неопределено. 476 | // 477 | Функция ПолучитьПервый() 478 | ``` 479 | 480 | #### ВМассив 481 | 482 | ```bsl 483 | // Получить коллекцию в виде массива. 484 | // Терминальный метод. 485 | // 486 | // Возвращаемое значение: 487 | // Массив - Массив элементов коллекции. 488 | // 489 | Функция ВМассив() 490 | ``` 491 | 492 | #### ВСтроку 493 | 494 | ```bsl 495 | // Получить коллекцию в виде строки. 496 | // Терминальный метод. 497 | // 498 | // Параметры: 499 | // РазделительСтрок - Строка - Используемый разделитель между элементами при конкатенации строк. 500 | // 501 | // Возвращаемое значение: 502 | // Строка - Элементы коллекции, соединенные в строку методом конкатенации. 503 | // 504 | Функция ВСтроку(РазделительСтрок = "") 505 | ``` 506 | 507 | #### Количество 508 | 509 | ```bsl 510 | // Получить количество элементов коллекции. 511 | // Терминальный метод. 512 | // 513 | // Возвращаемое значение: 514 | // Число - Количество элементов коллекции. 515 | // 516 | Функция Количество() 517 | ``` 518 | 519 | #### ДляКаждого 520 | 521 | ```bsl 522 | // Обработать каждый элемент коллекции и завершить работу процессора. 523 | // Терминальный метод. 524 | // 525 | // Параметры: 526 | // ФункцияОбработки - Строка - Лямбда выражение процедура с одним параметром в который будет передан элемент 527 | // - Действие - Делегат на процедуру с одним параметром в который будет передан элемент 528 | // 529 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 530 | // значения будут доступны по обращению к ключу как к переменной. 531 | // При передачи действия в первом параметре, этот параметр игнорируется 532 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 533 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 534 | // При передачи действия в первом параметре, этот параметр игнорируется 535 | // 536 | // Примеры: 537 | // // 1: 538 | // ПроцессорКоллекций.ДляКаждого("Элемент -> Сообщить(Элемент);"); 539 | // 540 | // // 2: 541 | // Процедура МояПроцедураОбработки(Элемент) Экспорт 542 | // Сообщить(Элемент); 543 | // КонецПроцедуры 544 | // 545 | // ПроцедураОбработки = Новый Действие(ЭтотОбъект, "МояПроцедураОбработки"); 546 | // ПроцессорКоллекций.ДляКаждого(ПроцедураОбработки); 547 | // 548 | Процедура ДляКаждого(Знач ФункцияОбработки, Знач ДополнительныеПараметры = Неопределено) 549 | ``` 550 | 551 | #### Минимум 552 | 553 | ```bsl 554 | // Получить минимальный элемент. 555 | // Терминальный метод. 556 | // 557 | // Параметры: 558 | // ФункцияСравнения - Строка - Лямбда выражение функция с двумя параметрами в которые будут переданы два элемента, 559 | // и которая возвращает Число, 1 - если первый элемент больше, -1 если второй элемент больше, 0 - если элементы равны 560 | // - Действие - Делегат на функцию с двумя параметрами, в которые будут переданы два элемента, 561 | // и которая возвращает Число, 1 - если первый элемент больше, -1 если второй элемент больше, 0 - если элементы равны 562 | // - Неопределено - см. ПроцессорыКоллекций.СтандартнаяФункцияСравненияПрямойПорядок(), 563 | // проверка через ">", "<", "=" 564 | // 565 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 566 | // значения будут доступны по обращению к ключу как к переменной. 567 | // При передачи действия в первом параметре, этот параметр игнорируется 568 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 569 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 570 | // При передачи действия в первом параметре, этот параметр игнорируется 571 | // 572 | // Возвращаемое значение: 573 | // Произвольный - минимальный элемент коллекции. 574 | // 575 | // Примеры: 576 | // // 1: 577 | // ПроцессорКоллекций.Минимум(); 578 | // 579 | // // 2: 580 | // ПроцессорКоллекций.Минимум("(Первый, Второй) -> 581 | // | Если Первый > Второй Тогда Возврат 1; 582 | // | ИначеЕсли Второй > Первый Тогда Возврат -1; 583 | // | Иначе Возврат 0; 584 | // | КонецЕсли;" 585 | // ); 586 | // 587 | // // 3: 588 | // Функция МояФункцияСравнения(Первый, Второй) Экспорт 589 | // Если Первый > Второй Тогда 590 | // Возврат 1; 591 | // ИначеЕсли Второй > Первый Тогда 592 | // Возврат -1; 593 | // Иначе 594 | // Возврат 0; 595 | // КонецЕсли; 596 | // КонецФункции 597 | // 598 | // ФункцияСравнения = Новый Действие(ЭтотОбъект, "МояФункцияСравнения"); 599 | // ПроцессорКоллекций.Минимум(ФункцияСравнения); 600 | // 601 | Функция Минимум(Знач ФункцияСравнения = Неопределено, Знач ДополнительныеПараметры = Неопределено) 602 | ``` 603 | 604 | #### Максимум 605 | 606 | ```bsl 607 | // Получить максимальный элемент. 608 | // Терминальный метод. 609 | // 610 | // Параметры: 611 | // ФункцияСравнения - Строка - Лямбда выражение функция с двумя параметрами в которые будут переданы два элемента, 612 | // и которая возвращает Число, 1 - если первый элемент больше, -1 если второй элемент больше, 0 - если элементы равны 613 | // - Действие - Делегат на функцию с двумя параметрами, в которые будут переданы два элемента, 614 | // и которая возвращает Число, 1 - если первый элемент больше, -1 если второй элемент больше, 0 - если элементы равны 615 | // - Неопределено - см. ПроцессорыКоллекций.СтандартнаяФункцияСравненияПрямойПорядок(), 616 | // проверка через ">", "<", "=" 617 | // 618 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 619 | // значения будут доступны по обращению к ключу как к переменной. 620 | // При передачи действия в первом параметре, этот параметр игнорируется 621 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 622 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 623 | // При передачи действия в первом параметре, этот параметр игнорируется 624 | // 625 | // Возвращаемое значение: 626 | // Произвольный - максимальный элемент коллекции. 627 | // 628 | // Примеры: 629 | // // 1: 630 | // ПроцессорКоллекций.Максимум(); 631 | // 632 | // // 2: 633 | // ПроцессорКоллекций.Максимум("(Первый, Второй) -> 634 | // | Если Первый > Второй Тогда Возврат 1; 635 | // | ИначеЕсли Второй > Первый Тогда Возврат -1; 636 | // | Иначе Возврат 0; 637 | // | КонецЕсли;" 638 | // ); 639 | // 640 | // // 3: 641 | // Функция МояФункцияСравнения(Первый, Второй) Экспорт 642 | // Если Первый > Второй Тогда 643 | // Возврат 1; 644 | // ИначеЕсли Второй > Первый Тогда 645 | // Возврат -1; 646 | // Иначе 647 | // Возврат 0; 648 | // КонецЕсли; 649 | // КонецФункции 650 | // 651 | // ФункцияСравнения = Новый Действие(ЭтотОбъект, "МояФункцияСравнения"); 652 | // ПроцессорКоллекций.Максимум(ФункцияСравнения); 653 | // 654 | Функция Максимум(Знач ФункцияСравнения = Неопределено, Знач ДополнительныеПараметры = Неопределено) 655 | ``` 656 | 657 | #### Сократить 658 | 659 | ```bsl 660 | // Выполнить агрегатную функцию над элементами коллекции. 661 | // Терминальный метод. 662 | // 663 | // Параметры: 664 | // ФункцияСокращения - Строка - Лямбда выражение функция с двумя параметрами в которые будут переданы 665 | // результат аккумулятор и очередной элемент коллекции, и которая возвращает новое значение результата 666 | // - Действие - Делегат на функцию с двумя параметрами в которые будут переданы 667 | // результат аккумулятор и очередной элемент коллекции, и которая возвращает новое значение результата 668 | // 669 | // НачальноеЗначение - Произвольный - начальное значение, передаваемое в функцию сокращения в параметр "Результат" 670 | // 671 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 672 | // значения будут доступны по обращению к ключу как к переменной. 673 | // При передачи действия в первом параметре, этот параметр игнорируется 674 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 675 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 676 | // При передачи действия в первом параметре, этот параметр игнорируется 677 | // 678 | // Возвращаемое значение: 679 | // Произвольный - результат работы агрегатной функции. 680 | // 681 | // Примеры: 682 | // 2: 683 | // ПроцессорКоллекций.Сократить("Результат, Элемент -> Результат + Элемент", 0); 684 | // 685 | // 2: 686 | // Функция МояФункцияСокращения(Результат, Элемент) Экспорт 687 | // Возврат Результат + Элемент; 688 | // КонецФункции 689 | // 690 | // ФункцияСокращения = Новый Действие(ЭтотОбъект, "МояФункцияСокращения"); 691 | // ПроцессорКоллекций.Сократить(ФункцияСокращения); 692 | // 693 | Функция Сократить(Знач ФункцияСокращения, Знач НачальноеЗначение = Неопределено, Знач ДополнительныеПараметры = Неопределено) 694 | ``` 695 | 696 | #### Получить 697 | 698 | ```bsl 699 | // Получить коллекцию в виде объекта заданного типа. 700 | // Терминальный метод. 701 | // 702 | // Параметры: 703 | // ТипРезультата - Тип - Тип, в котором необходимо вернуть коллекцию. 704 | // 705 | // Возвращаемое значение: 706 | // Произвольный - Коллекция в виде объекта нужного типа. 707 | // 708 | Функция Получить(ТипРезультата) 709 | ``` 710 | 711 | #### ЛюбойСоответствует 712 | 713 | ```bsl 714 | // Проверить, что хотя бы один элемент коллекции удовлетворяет условию в функции сравнения. 715 | // Терминальный метод. 716 | // 717 | // Параметры: 718 | // ФункцияСравнения - Строка - Лямбда выражение функция с одним параметром в который будет передан элемент, 719 | // и которая возвращает Булево, Истина если элемент проходит фильтр, ложь в противном случае 720 | // - Действие - Делегат на функцию с одним параметром в который будет передан элемент, 721 | // и которая возвращает Булево, Истина если элемент проходит фильтр, ложь в противном случае 722 | // 723 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 724 | // значения будут доступны по обращению к ключу как к переменной. 725 | // При передачи действия в первом параметре, этот параметр игнорируется 726 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 727 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 728 | // При передачи действия в первом параметре, этот параметр игнорируется 729 | // 730 | // Возвращаемое значение: 731 | // Булево - Истина, если минимум один из элементов коллекции удовлетворяет условию Функции сравнения. 732 | // В обратном случае возвращает Ложь. 733 | // Если коллекция пустая, возвращает Ложь. 734 | // 735 | Функция ЛюбойСоответствует(Знач ФункцияСравнения, Знач ДополнительныеПараметры = Неопределено) 736 | ``` 737 | 738 | #### ВсеСоответствуют 739 | 740 | ```bsl 741 | // Проверить, что все элементы коллекции удовлетворяют условию в функции сравнения. 742 | // Терминальный метод. 743 | // 744 | // Параметры: 745 | // ФункцияСравнения - Строка - Лямбда выражение функция с одним параметром в который будет передан элемент, 746 | // и которая возвращает Булево, Истина если элемент проходит фильтр, ложь в противном случае 747 | // - Действие - Делегат на функцию с одним параметром в который будет передан элемент, 748 | // и которая возвращает Булево, Истина если элемент проходит фильтр, ложь в противном случае 749 | // 750 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 751 | // значения будут доступны по обращению к ключу как к переменной. 752 | // При передачи действия в первом параметре, этот параметр игнорируется 753 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 754 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 755 | // При передачи действия в первом параметре, этот параметр игнорируется 756 | // 757 | // Возвращаемое значение: 758 | // Булево - Истина, если все элементы коллекции удовлетворяют условию Функции сравнения. 759 | // В обратном случае возвращает Ложь. 760 | // Если коллекция пустая, возвращает Истина. 761 | // 762 | Функция ВсеСоответствуют(Знач ФункцияСравнения, Знач ДополнительныеПараметры = Неопределено) 763 | ``` 764 | 765 | #### ВсеНеСоответствуют 766 | 767 | ```bsl 768 | // Проверить, что все элементы коллекции не удовлетворяют условию в функции сравнения. 769 | // Терминальный метод. 770 | // 771 | // Параметры: 772 | // ФункцияСравнения - Строка - Лямбда выражение функция с одним параметром в который будет передан элемент, 773 | // и которая возвращает Булево, Истина если элемент проходит фильтр, ложь в противном случае 774 | // - Действие - Делегат на функцию с одним параметром в который будет передан элемент, 775 | // и которая возвращает Булево, Истина если элемент проходит фильтр, ложь в противном случае 776 | // 777 | // ДополнительныеПараметры - Структура - Контекст добавляемый в лямбда выражение, 778 | // значения будут доступны по обращению к ключу как к переменной. 779 | // При передачи действия в первом параметре, этот параметр игнорируется 780 | // - Сценарий - Экземпляр объекта, который будет захвачен в лямбда выражение, 781 | // в лямбда выражении будет доступен контекст (публичные и приватные поля, публичные методы) объекта. 782 | // При передачи действия в первом параметре, этот параметр игнорируется 783 | // 784 | // Возвращаемое значение: 785 | // Булево - Истина, если все элементы коллекции не удовлетворяют условию Функции сравнения. 786 | // В обратном случае возвращает Ложь. 787 | // Если коллекция пустая, возвращает Истина. 788 | // 789 | Функция ВсеНеСоответствуют(Знач ФункцияСравнения, Знач ДополнительныеПараметры = Неопределено) 790 | ``` 791 | 792 | ### Модуль ПроцессорыКоллекций 793 | 794 | #### ИзКоллекции 795 | 796 | ```bsl 797 | // Создать ПроцессорКоллекций на основании переданной коллекции. 798 | // 799 | // Параметры: 800 | // Коллекция - Произвольный - Коллекция (Массив, ТаблицаЗначений...), на основании которой нужно 801 | // сформировать ПроцессорКоллекций. 802 | // 803 | // Возвращаемое значение: 804 | // ПроцессорКоллекций - Инстанс класса ПроцессорКоллекций, заполненный переданной коллекцией. 805 | // 806 | Функция ИзКоллекции(Коллекция) Экспорт 807 | ``` 808 | 809 | #### ИзСтроки 810 | 811 | ```bsl 812 | // Создать ПроцессорКоллекций на основании переданной строки. 813 | // Переданная строка преобразуется в коллекцию путем разделения строк. 814 | // 815 | // Параметры: 816 | // Строка - Строка - Строка, на основании которой нужно сформировать ПроцессорКоллекций. 817 | // РазделительСтрок - Строка - Разделитель строк, применяемый к Строке для получения коллекции. 818 | // Если не передан, строка разделяется на элементы посимвольно. 819 | // ВключатьПустые - Булево - Указывает необходимость включать в коллекцию пустые строки, 820 | // которые могут образоваться в результате разделения исходной строки. 821 | // 822 | // Возвращаемое значение: 823 | // ПроцессорКоллекций - Инстанс класса ПроцессорКоллекций. 824 | // 825 | Функция ИзСтроки(Строка, РазделительСтрок = Неопределено, ВключатьПустые = Истина) Экспорт 826 | ``` 827 | 828 | #### ИзНабора 829 | 830 | ```bsl 831 | // Создать ПроцессорКоллекций на основании переданного набора значений. 832 | // Добавляет элемент в ПроцессорКоллекций, если он не равен NULL. 833 | // 834 | // Параметры: 835 | // Элемент1 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 836 | // Элемент2 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 837 | // Элемент3 - Произвольный - Элемент для добавления в ПроцессорКоллекций. 838 | // ... Всего 32 параметра ... 839 | // 840 | // Возвращаемое значение: 841 | // ПроцессорКоллекций - Инстанс класса ПроцессорКоллекций, заполненный переданным набором. 842 | // 843 | Функция ИзНабора(Элемент1 = NULL, Элемент2 = NULL, Элемент3 = NULL, ...) Экспорт 844 | ``` 845 | 846 | #### СтандартнаяФункцияСравненияПрямойПорядок 847 | 848 | ```bsl 849 | // Стандартная функция сравнения. 850 | // Сравнивает значения элементов коллекции через операторы ">", "<" и "=". 851 | // 852 | // Возвращаемое значение: 853 | // Действие - Делегат на стандартный метод сравнения 854 | // 855 | Функция СтандартнаяФункцияСравненияПрямойПорядок() 856 | ``` 857 | 858 | #### СтандартнаяФункцияСравненияОбратныйПорядок 859 | 860 | ```bsl 861 | // Стандартная функция сравнения в обратном порядке 862 | // Сравнивает значения элементов коллекции через операторы ">", "<" и "=". 863 | // 864 | // Возвращаемое значение: 865 | // Действие - Делегат на стандартный метод сравнения в обратном порядке 866 | // 867 | Функция СтандартнаяФункцияСравненияОбратныйПорядок() 868 | ``` 869 | 870 | #### СтандартнаяФункцияРавенства 871 | 872 | ```bsl 873 | // Стандартная функция проверки на равенство 874 | // Сравнивает значения элементов коллекции через "=". 875 | // 876 | // Возвращаемое значение: 877 | // Действие - Делегат на стандартный метод проверки на равенство 878 | // 879 | Функция СтандартнаяФункцияРавенства() 880 | ``` 881 | 882 | ### Отладка методов 883 | 884 | Для того, что бы работал отладчик и заходил в добавленные методы нужно: Либо установить любое значение переменной окружения с именем ```OSCRIPT_FLUENT_DEBUG```. Либо вызвать метод ```Отладка()``` 885 | 886 | --- 887 | Вдохновение черпалось из java8 stream-api. 888 | --------------------------------------------------------------------------------